LVDT/RVDT Measurement (LD) Family Guide

Overview

The LD family is NAI’s line of LVDT-to-Digital and RVDT-to-Digital measurement smart function modules. It is the close sibling of the SD family — both read a rugged AC transformer position sensor and convert it to a digital value — but they answer different questions. An SD module asks “what angle is this shaft at?” for things that rotate continuously through a full, unlimited 360°. An LD module asks “how far has this thing moved?” for things that travel along a bounded path — a linear stroke, or a shaft that pivots through a limited arc. Each LD module has four independent channels and reports both position and velocity.

That distinction is the first thing to settle when deciding whether you want an LD at all:

Full-circle, continuous, absolute angle (a gimbal, antenna pedestal, turret) → a synchro/resolver → the SD family.
Linear travel (an actuator ram, a valve spool) or limited-range rotary (a throttle lever, a control-surface hinge swinging ±40–60°) → an LVDT/RVDT → LD.

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 (relative to the reference) says which way — the same ratiometric, AC-carrier principle as a synchro/resolver, mapped to straight-line travel. An RVDT (Rotary Variable Differential Transformer) is the same device on a shaft, measuring limited-range rotary displacement as a linear-proportional function (not full-circle). NAI treats the two identically — “the fundamental operation and interface for both are essentially the same” — so one LD channel reads either.

These sensors are favored wherever a system needs rugged, contactless, absolute position feedback in a harsh environment: the core never touches the coils, so there’s nothing to wear out, and they shrug off vibration, temperature, shock, and contamination far better than potentiometers or optical encoders. In a real system, an LD module is the position-feedback front-end. Concretely, it reads position from: flight-control-surface actuators (flap, slat, aileron, rudder, spoiler ram travel), engine controls / FADEC (fuel-metering valve, variable stator/guide vanes, nozzle and thrust-reverser position), landing gear and doors (extend/retract, up-and-locked), throttle/power-lever and pedal position (often RVDTs on a pivot), and valve, brake, and actuator feedback generally — plus industrial press, servo-valve, and machine-tool slide position.

(The angle-measuring sibling is the SD family; the mirror-image generator — which produces synchro/resolver signals rather than reading them — is the DS/DR family. SD and LD measure; DS generates.)

LD modules at a glance

All five members are 4-channel LVDT/RVDT-to-digital converters. Like SD, they differ by the excitation frequency band and input voltage they handle — because LVDTs and RVDTs run at different carrier frequencies and signal levels. Pick the model whose ranges bracket your sensor.

Module	Channels	Input voltage (RMS)	Excitation frequency	Manual
LD1	4	2–28 V	47 Hz – 1 kHz	LD1-LD5 Manual
LD2	4	2–28 V	1 – 5 kHz	LD1-LD5 Manual
LD3	4	2–28 V	5 – 10 kHz	LD1-LD5 Manual
LD4	4	2–28 V	10 – 20 kHz	LD1-LD5 Manual
LD5	4	28–90 V	47 Hz – 1 kHz	LD1-LD5 Manual

Choosing a member:

Standard 400 Hz aircraft LVDTs/RVDTs (low-level signals) — LD1 (47 Hz–1 kHz, 2–28 V).
Higher-frequency excitation — LD2 (1–5 kHz), LD3 (5–10 kHz), or LD4 (10–20 kHz), 2–28 V.
High-level signals (28–90 V line, 115 V-class excitation) at 400 Hz — LD5.
LVDT or RVDT is not a model choice — every channel reads both; the module measures displacement the same way for each.
Wiring mode is per channel, in software — a channel runs in 4-wire mode (one LVDT) or 2-wire mode (two independent LVDTs, A and B, on one channel); set it with naibrd_LVDT_SetChanMode.

Note

A 2-channel LVDT variant (LD6) is also built into the 68CB6 combination motherboard; it uses the same naibrd_LVDT_* API. Confirm exact models and ranges on the LDx data sheet and the LD1-LD5 Manual.

Physical setup

An LD channel connects to an LVDT or RVDT through two things: the reference (excitation) pair that drives the sensor’s primary winding, and the secondary signal lines that carry the position back. 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 LD module:

Identify the module’s slot number on your NAI motherboard or system.
Bring the channel’s lines out through the breakout board, where the slot’s pins appear as generic IO# numbers.
Map IO# pins to the channel’s reference (excitation) lines and the sensor’s secondary signal lines, per the pinout in the manual.
Connect the LVDT/RVDT leads accordingly.

A few things hold for every LD module:

Set the channel mode to match how the sensor is wired. A single LVDT/RVDT uses 4-wire mode; 2-wire mode lets one channel read two independent sensors (A and B). Set it with naibrd_LVDT_SetChanMode (NAIBRD_LVDT_4WIRE / NAIBRD_LVDT_2WIRE). The wrong mode misreads the signals.
Match the model to the excitation. The reference frequency and signal voltage must fall within the model’s bands (see the table). The module can supply the excitation itself (programmable on-board reference voltage and frequency) or lock to an external reference.
Set the sensor’s transformation ratio and scale. LVDTs/RVDTs are specified by a transformation ratio (TR) and full-scale travel; set them (naibrd_LVDT_SetTRValue, naibrd_LVDT_SetLVDTScale) so the digital position maps correctly to physical units. Fine offset/scale calibration is available per channel in floating-point.
Wiring integrity is monitored. Each channel detects an open or shorted sensor connection and signal/reference under- and over-voltage faults against programmable thresholds (naibrd_LVDT_SetThreshold) — useful for catching a broken or chafed sensor lead in the field.
Tracking bandwidth is configurable. The converter tracks the moving core with a selectable bandwidth (manual or automatic), trading noise against response speed (naibrd_LVDT_SetBandwidthSelect).

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

Reading a 4-wire LVDT on a linear actuator. Wire the sensor’s primary to the channel’s reference pair and its secondaries to the channel’s signal lines, set the channel to 4-wire mode, and read the position — it should track the ram as it extends.
Reading an RVDT. Wire it the same way, set the channel mode, and read the position as the shaft pivots through its rated arc.
Reading two LVDTs on one channel. Put the channel in 2-wire mode and read sensor A and sensor B independently (naibrd_LVDT_GetTwoWirePosition with NAIBRD_LVDT_TWO_WIRE_A / _B).

Software

There’s nothing LD-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 LD module. The only family-specific part is which API functions you call: LD modules use the naibrd_LVDT_* calls (the API is named for the sensor — LVDT — not the module).

LD 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 LD1-LD5 Manual documents every naibrd_LVDT_* register (channel/wire mode, bandwidth, TR and scale, fault thresholds, BIT, and position/velocity/voltage/frequency 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 an LD1 module: pull the naibrd_LVDT_* calls from the LD1-LD5 Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch an LVDT sample on the target per Running Applications from the Target.

Confirm communication

An LD module measures an external sensor, but it doesn’t need one connected to prove the path works — it can inject a known position internally, exactly as SD injects a test angle.

Built-in test (no wiring). Every LD module runs a power-on self-test that checks each channel, plus continuous background BIT. Confirm the power-on BIT completed and that no BIT fault is latched:

bool_t pbitComplete = NAI_FALSE;
naibrd_LVDT_CheckPowerOnBITComplete(cardIndex, module, &pbitComplete);   /* power-on BIT done? */
 
nai_status_bit_t bitStatus;
naibrd_LVDT_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_LVDT_CHAN_MAPPED_STATUS_BIT_LATCHED, &bitStatus);             /* any BIT fault? (LO = normal) */

Internal test-position injection (step up — no sensor needed). Enable the module’s D0 test mode and set a test position; the module substitutes that value for the real input, so every channel should read it back within the BIT error limit. This exercises the whole conversion pipeline with nothing wired to the front panel:

naibrd_LVDT_SetTestPosition(cardIndex, module, 50.0);                    /* simulate 50% of full-scale */
naibrd_LVDT_SetModuleBITEnable(cardIndex, module,
   NAIBRD_LVDT_TEST_ENABLE_D0, NAI_TRUE);                               /* turn on D0 internal test */
 
float64_t position;
naibrd_LVDT_GetPosition(cardIndex, module, channel, &position);         /* should read ~the injected value */

If power-on BIT is complete, BIT status is clean, and the injected test position reads back correctly, your board connection, the SSK, and the module’s full measurement path are all confirmed.

Known-position sanity read (proves you can read a real sensor). Connect an LVDT/RVDT, set the channel mode, move the core to a known position, and read it back:

naibrd_LVDT_SetChanMode(cardIndex, module, channel, NAIBRD_LVDT_4WIRE);  /* match your sensor wiring */
naibrd_LVDT_GetPosition(cardIndex, module, channel, &position);          /* should match the core position */

A position that matches the known core position confirms the full path end-to-end, including a real sensor. The LVDT BasicOps sample drives exactly this flow — mode, thresholds, BIT, and reading position/velocity/voltage across channels.

Features

Each LD operation works per channel through the naibrd_LVDT_* API. The blocks below group the calls by what you’re doing — think of them like the controls on ESP2’s LVDT tab — with the SSK 1.x and 2.x signatures side by side. (The 1.x → 2.x rename is visible throughout: nai_lvdt_* enum types became naibrd_lvdt_*, GetStatus/ClearStatus became per-channel GetChanMappedStatus/ClearChanMappedStatus, and out-parameters gained the p_out prefix.)

Read a channel — position, velocity & two-wire

What it does: read the converted position and rotational/linear velocity the tracking converter produces. In 2-wire mode, read the two sensors (A and B) on the channel separately. Latch first for a coherent snapshot across channels.

Applies to: all LD modules. The TwoWire reads apply when the channel is in 2-wire mode.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_LVDT_GetPosition(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outposition);
nai_status_t naibrd_LVDT_GetVelocity(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outvelocity);
nai_status_t naibrd_LVDT_GetTwoWirePosition(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t* p_outposition);
nai_status_t naibrd_LVDT_GetTwoWireVelocity(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t* p_outvelocity);
nai_status_t naibrd_LVDT_SetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t latch);
nai_status_t naibrd_LVDT_GetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* outlatch);

/* SSK 2.x */
nai_status_t naibrd_LVDT_GetPosition(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outposition);
nai_status_t naibrd_LVDT_GetVelocity(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outvelocity);
nai_status_t naibrd_LVDT_GetTwoWirePosition(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t* p_outposition);
nai_status_t naibrd_LVDT_GetTwoWireVelocity(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t* p_outvelocity);
nai_status_t naibrd_LVDT_SetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t latch);
nai_status_t naibrd_LVDT_GetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* p_outlatch);

Exercise it: LVDT BasicOps · LVDT BasicOps (1.x) · ESP2 “LVDT” tab.

Configure the channel

What it does: set up how the channel measures before you read it — the wire mode (4-wire single sensor / 2-wire dual sensor), tracking bandwidth, full-scale LVDT scale and transformation ratio (TR), fault thresholds, channel enable, and per-channel floating-point offset/scale calibration.

Applies to: all LD modules. Two-wire TR and the floating-point attributes take a NAIBRD_LVDT_TWO_WIRE_A / _B selector.

Also here: naibrd_LVDT_SetChanMode uses NAIBRD_LVDT_4WIRE / NAIBRD_LVDT_2WIRE; bandwidth select is NAIBRD_LVDT_BW_MANUAL / NAIBRD_LVDT_BW_AUTOMATIC; thresholds cover open, short, and signal/reference hi/lo. Set the transformation ratio with naibrd_LVDT_SetTRValue (4-wire) or naibrd_LVDT_SetTwoWireTRValue (2-wire).

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_LVDT_SetChanMode(int32_t cardIndex, int32_t module, int32_t channel, nai_lvdt_format_t mode);
nai_status_t naibrd_LVDT_SetBandwidthSelect(int32_t cardIndex, int32_t module, int32_t channel, nai_lvdt_bandwidth_select_t bwselect);
nai_status_t naibrd_LVDT_SetLVDTScale(int32_t cardIndex, int32_t module, int32_t channel, uint32_t scale);
nai_status_t naibrd_LVDT_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_threshold_t type, float64_t threshold);
nai_status_t naibrd_LVDT_SetFloatingPointPositionScale(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t positionScale);
nai_status_t naibrd_LVDT_SetFloatingPointPositionOffset(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t positionOffset);
nai_status_t naibrd_LVDT_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t setting);

/* SSK 2.x */
nai_status_t naibrd_LVDT_SetChanMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_format_t mode);
nai_status_t naibrd_LVDT_SetBandwidthSelect(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_bandwidth_select_t bwSelect);
nai_status_t naibrd_LVDT_SetLVDTScale(int32_t cardIndex, int32_t module, int32_t channel, uint32_t scale);
nai_status_t naibrd_LVDT_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_threshold_t type, float64_t threshold);
nai_status_t naibrd_LVDT_SetFloatingPointPositionScale(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t positionScale);
nai_status_t naibrd_LVDT_SetFloatingPointPositionOffset(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_2_wire_t type, float64_t positionOffset);
nai_status_t naibrd_LVDT_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

Exercise it: LVDT BasicOps · LVDT BasicOps (1.x) · ESP2 “LVDT” tab.

Measure the signals

What it does: read the channel’s raw electrical measurements — excitation frequency, signal voltage, and reference voltage — for monitoring signal health beyond the decoded position.

Applies to: all LD modules. (2.x adds naibrd_LVDT_GetSignalMagnitude for the per-secondary signal magnitudes.)

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_LVDT_GetFrequency(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outfrequency);
nai_status_t naibrd_LVDT_GetSignalVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outsigvolt);
nai_status_t naibrd_LVDT_GetRefVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outrefvolt);

/* SSK 2.x */
nai_status_t naibrd_LVDT_GetFrequency(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outfrequency);
nai_status_t naibrd_LVDT_GetSignalVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outsigVolt);
nai_status_t naibrd_LVDT_GetRefVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outrefVolt);
nai_status_t naibrd_LVDT_GetSignalMagnitude(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_signal_type_t type, float64_t* p_outsignal);

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

Health, BIT & status

What it does: run and tune Built-In Test and read the channel’s fault flags. D0 injects a test position; D2 is the continuous background test (with a verify value); D3 is the offline initiated test. The channel-mapped status reports BIT, signal-fault (hi/lo), reference-fault (hi/lo), open, short, delta-position, and a summary — each in real-time and latched form.

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

Also here: test types are NAIBRD_LVDT_TEST_ENABLE_D0 / _D3; status types are NAIBRD_LVDT_CHAN_MAPPED_STATUS_* (BIT, SIGNAL_FAULT_LOW/HIGH, REF_FAULT_LOW/HIGH, OPEN, SHORT, DELTA_POS, SUMMARY, each _LATCHED / _REALTIME); SetBITErrorLimit sets the pass/fail tolerance for the D0 readback.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_LVDT_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_LVDT_SetModuleBITEnable(int32_t cardIndex, int32_t module, nai_lvdt_test_enable_t type, bool_t bitEnable);
nai_status_t naibrd_LVDT_SetBITErrorLimit(int32_t cardIndex, int32_t module, int32_t channel, float64_t bitErrorLimit);
nai_status_t naibrd_LVDT_SetTestPosition(int32_t cardIndex, int32_t module, float64_t testposition);
nai_status_t naibrd_LVDT_SetD2TestVerifyValue(int32_t cardIndex, int32_t module, uint32_t value);
nai_status_t naibrd_LVDT_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_lvdt_status_type_t type, uint32_t* outstatus);
nai_status_t naibrd_LVDT_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_lvdt_status_type_t type);

/* SSK 2.x */
nai_status_t naibrd_LVDT_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_LVDT_SetModuleBITEnable(int32_t cardIndex, int32_t module, naibrd_lvdt_test_enable_t type, bool_t bitEnable);
nai_status_t naibrd_LVDT_SetBITErrorLimit(int32_t cardIndex, int32_t module, int32_t channel, float64_t bitErrorLimit);
nai_status_t naibrd_LVDT_SetTestPosition(int32_t cardIndex, int32_t module, float64_t testPosition);
nai_status_t naibrd_LVDT_SetD2TestVerifyValue(int32_t cardIndex, int32_t module, uint32_t value);
nai_status_t naibrd_LVDT_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_chan_mapped_status_type_t statusType, nai_status_bit_t* p_outstatusBit);
nai_status_t naibrd_LVDT_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_lvdt_chan_mapped_status_type_t statusType);

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

Try it

The snippets below show the order of naibrd_LVDT_* calls for each task — drop them into the body of an NAI sample app (after the standard 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 read. Each is the conceptual sequence, not a fully-buildable program; the LVDT BasicOps sample is the full reference. LD calls are stateless — there is no Open/Init/Free.

Try it — Read position and velocity

Set the channel’s wire mode, latch for a coherent snapshot, then read the decoded position and velocity.

/* SSK 1.x — read one LVDT's position and velocity */
naibrd_LVDT_SetChanMode(cardIndex, module, channel, NAI_LVDT_4WIRE);
naibrd_LVDT_SetLatch(cardIndex, module, channel, 1);              /* coherent snapshot */
 
float64_t position, velocity;
naibrd_LVDT_GetPosition(cardIndex, module, channel, &position);
naibrd_LVDT_GetVelocity(cardIndex, module, channel, &velocity);

/* SSK 2.x — read one LVDT's position and velocity */
naibrd_LVDT_SetChanMode(cardIndex, module, channel, NAIBRD_LVDT_4WIRE);
naibrd_LVDT_SetLatch(cardIndex, module, channel, 1);              /* coherent snapshot */
 
float64_t position, velocity;
naibrd_LVDT_GetPosition(cardIndex, module, channel, &position);
naibrd_LVDT_GetVelocity(cardIndex, module, channel, &velocity);

Try it — Read two LVDTs on one channel (2-wire)

Put the channel in 2-wire mode and read sensor A and sensor B independently.

/* SSK 1.x — two sensors on one channel */
naibrd_LVDT_SetChanMode(cardIndex, module, channel, NAI_LVDT_2WIRE);
 
float64_t posA, posB;
naibrd_LVDT_GetTwoWirePosition(cardIndex, module, channel, NAIBRD_LVDT_TWO_WIRE_A, &posA);
naibrd_LVDT_GetTwoWirePosition(cardIndex, module, channel, NAIBRD_LVDT_TWO_WIRE_B, &posB);

/* SSK 2.x — two sensors on one channel */
naibrd_LVDT_SetChanMode(cardIndex, module, channel, NAIBRD_LVDT_2WIRE);
 
float64_t posA, posB;
naibrd_LVDT_GetTwoWirePosition(cardIndex, module, channel, NAIBRD_LVDT_TWO_WIRE_A, &posA);
naibrd_LVDT_GetTwoWirePosition(cardIndex, module, channel, NAIBRD_LVDT_TWO_WIRE_B, &posB);

Try it — Self-test with an injected position

Inject a known test position with the D0 test, then read it back on a channel — no sensor wired. The latched BIT status should stay clean.

/* SSK 1.x — inject a test position, read it back, check BIT */
naibrd_LVDT_SetTestPosition(cardIndex, module, 50.0);                       /* 50% of full-scale */
naibrd_LVDT_SetModuleBITEnable(cardIndex, module, NAI_LVDT_TEST_ENABLE_D0, TRUE);
 
float64_t position;
naibrd_LVDT_GetPosition(cardIndex, module, channel, &position);            /* ~ injected value */
 
uint32_t bit;
naibrd_LVDT_GetStatus(cardIndex, module, channel, NAI_LVDT_STATUS_BIT_LATCHED, &bit);

/* SSK 2.x — inject a test position, read it back, check BIT */
naibrd_LVDT_SetTestPosition(cardIndex, module, 50.0);                       /* 50% of full-scale */
naibrd_LVDT_SetModuleBITEnable(cardIndex, module, NAIBRD_LVDT_TEST_ENABLE_D0, NAI_TRUE);
 
float64_t position;
naibrd_LVDT_GetPosition(cardIndex, module, channel, &position);            /* ~ injected value */
 
nai_status_bit_t bit;
naibrd_LVDT_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_LVDT_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 — LVDT BasicOps / LVDT Summary (2.x) and LVDT 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 read and configure each channel, see Features and Try it above.

What the hardware provides:

Tracking conversion — a closed-loop converter follows the moving core and gives lag-free position and velocity per channel, with transparent latches so valid data is always available.
Four isolated channels — isolated excitation and signal inputs let one module interface to virtually any LVDT/RVDT without ground-loop concerns.
Programmable on-board reference — the module can source the excitation (voltage + frequency) or lock to an external reference.
Selectable tracking bandwidth — manual or automatic, trading noise against response speed.
4-wire and 2-wire modes — one LVDT per channel, or two independent sensors (A/B) per channel.
Scaling and calibration — transformation ratio and full-scale LVDT scale, plus per-channel floating-point position/velocity offset and scale.
Wiring-fault detection — open- and short-circuit detection plus signal/reference under- and over-voltage, against programmable thresholds.
Built-in test — power-on self-test, continuous background D2 (with verify value), offline initiated D3, and D0 test-position injection with a programmable BIT error limit.

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

Status	What it tells you
BIT	A built-in-test fault on the channel
Signal fault (low / high)	The secondary signal level fell below / rose above its threshold
Reference fault (low / high)	The excitation/reference level is out of range
Open	An open circuit in the sensor wiring
Short	A short circuit in the sensor wiring
Delta position	The position changed by more than the configured delta (motion/violation detector)
Summary	A roll-up of the channel’s fault flags

ESP2’s status panel shows LVDT position and status interactively if you’d rather watch it in a GUI first.

Common pitfalls

Wrong wire mode. A single sensor must be read in 4-wire mode; reading it in 2-wire mode (or vice-versa) misinterprets the signals. Set naibrd_LVDT_SetChanMode to match the wiring.
Position doesn’t map to physical units. Set the transformation ratio and LVDT scale (and any floating-point offset/scale) so the decoded value matches your sensor’s full-scale travel — otherwise the number is uncalibrated.
Open / short status asserted. These flag a broken, shorted, or disconnected sensor lead. Check the wiring and the channel’s threshold settings before trusting the position.
Excitation out of band. The sensor’s reference frequency and voltage must fall within the model’s ranges (LD1–LD5) — or use the module’s on-board reference. An out-of-band reference reads as a reference fault.
Channels not coherent. For a synchronized multi-channel snapshot, latch (naibrd_LVDT_SetLatch) before reading; otherwise each read reflects a slightly different instant.
Reading before BIT completes. Check naibrd_LVDT_CheckPowerOnBITComplete before relying on BIT status or the first readings after power-up.

LD1-LD5 Manual — the LVDT/RVDT module manual (registers, full naibrd_LVDT_* API, model table)
SD Family Guide — the angle-measuring sibling (synchro/resolver-to-digital)
DS Family Guide — the mirror-image generator (digital-to-synchro/resolver)
DL Family Guide — the mirror-image family that generates LVDT/RVDT displacement (digital-to-LVDT/RVDT)
Download the SSK — get the library and sample apps
Connecting to Boards — power, network, terminal, and file transfer to your board
Opening a Software Handle to Your Board — establish the connection your naibrd_LVDT_* calls run against
Running Applications from the Target — load and launch a built sample on the board
LD sample applications — LVDT BasicOps · LVDT Summary (2.x) · LVDT BasicOps (1.x)
ESP2 Quick Start — read LVDT/RVDT channels with no code via the Embedded Soft Panel

NAI Documentation

Explorer

LD Module Guide

LVDT/RVDT Measurement (LD) Family Guide

Overview

LD modules at a glance

Physical setup

Software

Confirm communication

Features

Read a channel — position, velocity & two-wire

Configure the channel

Measure the signals

Health, BIT & status

Try it

Try it — Read position and velocity

Try it — Read two LVDTs on one channel (2-wire)

Try it — Self-test with an injected position

Hardware capabilities and status monitoring

Common pitfalls

Table of Contents

Backlinks

NAI Documentation

Explorer

LD Module Guide

LVDT/RVDT Measurement (LD) Family Guide

Overview

LD modules at a glance

Physical setup

Software

Confirm communication

Features

Read a channel — position, velocity & two-wire

Configure the channel

Measure the signals

Health, BIT & status

Try it

Try it — Read position and velocity

Try it — Read two LVDTs on one channel (2-wire)

Try it — Self-test with an injected position

Hardware capabilities and status monitoring

Common pitfalls

Related resources

Table of Contents

Backlinks