SD Family Guide

Overview

The SD family is NAI’s line of Synchro-to-Digital (S/D) and Resolver-to-Digital (R/D) measurement smart function modules. Where an AD module asks “how much voltage is on this line?”, an SD module asks “what angle is this shaft at?” — it reads a synchro or resolver position sensor and converts it to a precise digital angle (and rotational velocity) your software can read. Each module has four independent channels at 24-bit resolution.

This page is the starting point for any SD module. Use it to understand the family, pick the member that matches your sensor’s excitation frequency and signal voltage, wire a synchro/resolver to a channel, and confirm the module is measuring. It’s aimed at engineers reading shaft angle and rotational position from the rugged, transformer-type sensors used across mil-aero and industrial platforms.

Synchros and resolvers are transformer-type rotary transducers: an AC reference (excitation) carrier drives the sensor’s rotor, and its stator windings return signals whose amplitudes encode the shaft angle. A resolver gives two signals proportional to the sine and cosine of the angle; a synchro gives three line-to-line voltages 120° apart. They are brushless, absolute, and survive vibration, temperature, and contamination far better than optical encoders, which is why they dominate flight-grade position sensing. The SD module supplies (or accepts) the reference, reads those signals, and runs a closed-loop Type II tracking converter that continuously follows the angle — giving lag-free angle and velocity up to a specified tracking rate, with transparent latches so valid data is always available.

In a real system, an SD module is the position-feedback front-end. Concretely, it reads shaft angle from: flight-control-surface position (rudder, aileron, elevator, flap), gun/turret and antenna/radar-pedestal azimuth and elevation, gimbal and seeker pointing, engine and actuator feedback, INS/gyro platform gimbals, and industrial valve and motor shaft position. Two-speed (coarse/fine geared) sensors are supported for arc-second-class accuracy.

(The mirror-image sibling is the DS family, which generates synchro/resolver signals to drive a receiver or simulate a sensor — SD measures the angle, DS produces it. The linear-position cousins are the LD family, which measures LVDT/RVDT displacement, and the DL family, which generates it.)

SD modules at a glance

All five members are 4-channel, 24-bit S/D–R/D converters with 1 arc-min single-speed accuracy. They differ by the excitation frequency band and signal voltage they handle — because synchros and resolvers run at different carrier frequencies and signal levels. Pick the model whose ranges bracket your sensor.

Module	Channels	Resolution	Input voltage (RMS, L–L)	Excitation frequency	Manual
SD1	4	24-bit	2–28 V	47 Hz – 1 kHz	SD1-SD5 Manual
SD2	4	24-bit	2–28 V	1 – 5 kHz	SD1-SD5 Manual
SD3	4	24-bit	2–28 V	5 – 10 kHz	SD1-SD5 Manual
SD4	4	24-bit	2–28 V	10 – 20 kHz	SD1-SD5 Manual
SD5	4	24-bit	28–90 V	47 Hz – 1 kHz	SD1-SD5 Manual

Choosing a member:

Standard 400 Hz aircraft synchros/resolvers (low-level signals) — SD1 (47 Hz–1 kHz, 2–28 V).
Higher-frequency excitation — SD2 (1–5 kHz), SD3 (5–10 kHz), or SD4 (10–20 kHz), 2–28 V.
High-level signals (28–90 V line-to-line, e.g. 11.8 V or 90 V synchros) at 400 Hz — SD5.
By what you’re measuring — all members read both resolver (sin/cos) and synchro (3-wire) sensors; the choice is set per channel in software, not by the model.

Physical setup

An SD channel connects to a synchro or resolver through two things: the reference (excitation) pair that drives the sensor, and the signal lines that carry the angle 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 SD 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 lines (R1/R2) and signal lines — for a resolver, the sine pair (S1/S3) and cosine pair (S2/S4); for a synchro, the three stator lines (S1/S2/S3).
Connect the synchro/resolver leads accordingly.

A few things hold for every SD module:

Set the channel mode to match the transducer. A 4-wire sin/cos sensor is resolver mode; a 3-wire stator sensor is synchro mode (naibrd_SD_SetChanMode). The wrong mode misinterprets 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 or lock to an external reference; its synthetic-reference feature compensates up to ±60° of phase shift, so no external compensation network is needed.
Two-speed (coarse/fine) sensors pair adjacent channels. Channels are paired 1 & 2 and 3 & 4: the coarse and fine channels each read their own angle, and the combined high-accuracy angle is available too. Set the gear ratio with naibrd_SD_SetRatio.
The channels are isolated. Isolated excitation and signal inputs let one module interface to virtually any synchro/resolver without ground-loop concerns.

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

Reading a resolver. Wire the resolver’s rotor to the channel’s reference (R1/R2) pair, its sine winding to S1/S3, and its cosine winding to S2/S4. Set the channel to resolver mode and read the angle — it should track the shaft as you turn it.
Reading a 3-wire synchro. Wire the synchro’s stator lines to S1/S2/S3 and its rotor to the reference (R1/R2) pair. Set the channel to synchro mode and read the angle.

Software

There’s nothing SD-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 SD module. The only family-specific part is which API functions you call: SD modules use the naibrd_SD_* calls.

Where to find what you need:

Which functions/registers to call — the SD1-SD5 Manual documents every naibrd_SD_* register (channel mode, bandwidth, two-speed ratio, fault thresholds, BIT, angle/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 SD1 module: pull the naibrd_SD_* calls from the SD1-SD5 Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch an SD sample on the target per Running Applications from the Target.

Confirm communication

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

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

naibrd_SD_CheckPowerOnBITComplete(cardIndex, module, &complete);  /* power-on BIT done? */
naibrd_SD_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_SD_CHAN_MAPPED_STATUS_BIT_LATCHED, &bitStatus);         /* any BIT fault? (LO = normal) */

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

naibrd_SD_SetTestAngle(cardIndex, module, 45.0);                  /* simulate a 45° shaft */
naibrd_SD_SetModuleBITEnable(cardIndex, module,
   NAIBRD_SD_TEST_ENABLE_D0, NAI_TRUE);                           /* turn on D0 internal test */
naibrd_SD_GetAngle(cardIndex, module, channel, &angle);          /* should read ~45° on every channel */

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

Known-shaft sanity read (proves you can read a real sensor). Connect a synchro/resolver, set the channel mode, turn the shaft to a known position, and read it back:

naibrd_SD_SetChanMode(cardIndex, module, channel, NAIBRD_SD_RESOLVER);  /* match your sensor */
naibrd_SD_GetAngle(cardIndex, module, channel, &angle);                  /* should match the shaft */

An angle that matches the known shaft position confirms the full path end-to-end, including a real sensor. The SD BasicOps sample drives exactly this flow — mode, thresholds, BIT, and reading angle/frequency/voltage across channels.

Features

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

Read a channel — angle, velocity & raw sin/cos

What it does: read the converted shaft angle (degrees) and rotational velocity (deg/sec) the tracking converter produces, or the raw sine/cosine the channel sees. Latch first for a coherent snapshot across channels.

Applies to: all SD modules.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_SD_GetAngle(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outangle);
nai_status_t naibrd_SD_GetVelocity(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outvelocity);
nai_status_t naibrd_SD_GetSine(int32_t cardIndex, int32_t module, int32_t channel, float32_t* outsine);
nai_status_t naibrd_SD_GetCosine(int32_t cardIndex, int32_t module, int32_t channel, float32_t* outcosine);
nai_status_t naibrd_SD_SetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t latch);
nai_status_t naibrd_SD_GetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* outlatch);

/* SSK 2.x */
nai_status_t naibrd_SD_GetAngle(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outAngle);
nai_status_t naibrd_SD_GetVelocity(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outVelocity);
nai_status_t naibrd_SD_GetSine(int32_t cardIndex, int32_t module, int32_t channel, float32_t* p_outSine);
nai_status_t naibrd_SD_GetCosine(int32_t cardIndex, int32_t module, int32_t channel, float32_t* p_outCosine);
nai_status_t naibrd_SD_SetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t latch);
nai_status_t naibrd_SD_GetLatch(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* p_outLatch);

Exercise it: SD BasicOps (SSK 2.x) · SD BasicOps (SSK 1.x) · ESP2 “SD” tab.

Configure the channel — mode, bandwidth & two-speed

What it does: set the channel to resolver or synchro mode, set the tracking-loop bandwidth (manually or auto, 2 Hz–1280 Hz), and configure two-speed gear ratio and velocity scaling.

Applies to: all SD modules.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_SD_SetChanMode(int32_t cardIndex, int32_t module, int32_t channel, nai_sd_format_t mode);
nai_status_t naibrd_SD_GetChanMode(int32_t cardIndex, int32_t module, int32_t channel, nai_sd_format_t* outmode);
nai_status_t naibrd_SD_SetBandwidth(int32_t cardIndex, int32_t module, int32_t channel, uint32_t bandwidth);
nai_status_t naibrd_SD_SetBandwidthSelect(int32_t cardIndex, int32_t module, int32_t channel, nai_sd_bandwidth_select_t bwselect);
nai_status_t naibrd_SD_SetRatio(int32_t cardIndex, int32_t module, int32_t channel, uint32_t ratio);
nai_status_t naibrd_SD_SetVelScale(int32_t cardIndex, int32_t module, int32_t channel, uint32_t velscale);

/* SSK 2.x */
nai_status_t naibrd_SD_SetChanMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_format_t mode);
nai_status_t naibrd_SD_GetChanMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_format_t* p_outMode);
nai_status_t naibrd_SD_SetBandwidth(int32_t cardIndex, int32_t module, int32_t channel, uint32_t bandwidth);
nai_status_t naibrd_SD_SetBandwidthSelect(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_bandwidth_select_t bwSelect);
nai_status_t naibrd_SD_SetRatio(int32_t cardIndex, int32_t module, int32_t channel, uint32_t ratio);
nai_status_t naibrd_SD_SetVelScale(int32_t cardIndex, int32_t module, int32_t channel, uint32_t velScale);

Exercise it: SD BasicOps · ESP2 “SD” tab.

Signal & reference measurement, fault thresholds

What it does: measure the excitation frequency and the signal/reference RMS voltages the channel sees, and set the fault-detection thresholds (signal/reference under- and over-voltage, open, short) plus the delta-angle alert.

Applies to: all SD modules.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_SD_GetFrequency(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outfrequency);
nai_status_t naibrd_SD_GetSignalVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outsigvolt);
nai_status_t naibrd_SD_GetRefVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* outrefvolt);
nai_status_t naibrd_SD_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_threshold_t type, float64_t threshold);
nai_status_t naibrd_SD_SetAngleDelta(int32_t cardIndex, int32_t module, int32_t channel, float64_t angledelta);

/* SSK 2.x */
nai_status_t naibrd_SD_GetFrequency(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outFrequency);
nai_status_t naibrd_SD_GetSignalVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outSigVolt);
nai_status_t naibrd_SD_GetRefVoltage(int32_t cardIndex, int32_t module, int32_t channel, float64_t* p_outRefVolt);
nai_status_t naibrd_SD_SetThreshold(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_threshold_t type, float64_t threshold);
nai_status_t naibrd_SD_SetAngleDelta(int32_t cardIndex, int32_t module, int32_t channel, float64_t angleDelta);
nai_status_t naibrd_SD_SetAngleDataInit(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

Exercise it: SD BasicOps · ESP2 “SD” tab.

Health, BIT & status

What it does: run/monitor Built-In Test (power-on, continuous background, and the D0 internal test-angle injection), set the per-channel BIT error limit, and read or clear per-channel status.

Applies to: all SD modules.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_SD_SetModuleBITEnable(int32_t cardIndex, int32_t module, nai_sd_test_enable_t type, bool_t bitEnable);
nai_status_t naibrd_SD_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_SD_SetTestAngle(int32_t cardIndex, int32_t module, float64_t testangle);
nai_status_t naibrd_SD_SetBITErrorLimit(int32_t cardIndex, int32_t module, int32_t channel, float64_t bitErrorLimit);
nai_status_t naibrd_SD_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_sd_status_type_t type, uint32_t* outstatus);
nai_status_t naibrd_SD_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_sd_status_type_t type);

/* SSK 2.x */
nai_status_t naibrd_SD_SetModuleBITEnable(int32_t cardIndex, int32_t module, naibrd_sd_test_enable_t type, bool_t bitEnable);
nai_status_t naibrd_SD_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outPBitComplete);
nai_status_t naibrd_SD_SetTestAngle(int32_t cardIndex, int32_t module, float64_t testAngle);
nai_status_t naibrd_SD_SetBITErrorLimit(int32_t cardIndex, int32_t module, int32_t channel, float64_t bitErrorLimit);
nai_status_t naibrd_SD_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_chan_mapped_status_type_t type, nai_status_bit_t* p_outStatusBit);
nai_status_t naibrd_SD_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_sd_chan_mapped_status_type_t type);

Exercise it: SD BasicOps (BIT sub-menu) · ESP2 “SD” tab.

Try it

Reading a channel is the same regardless of which sample you run. Every NAI sample starts with the standard connection flow — naiapp_RunBoardMenu() opens or loads a board connection, then naiapp_query_CardIndex() and naiapp_query_ModuleNumber() pick the board and module slot (opened under the hood by naibrd_OpenDevice()), giving you the cardIndex / module / channel coordinates every naibrd_SD_* call takes. When you write your own program, you do the same — see Opening a Software Handle to Your Board.

Configuring a channel and reading the shaft angle looks like this (the calls the SD BasicOps sample uses):

/* SSK 1.x */
int32_t maxCh = naibrd_SD_GetChannelCount(modId);
 
/* Configure channel 1 as a resolver input */
naibrd_SD_SetChanMode(cardIndex, module, 1, NAI_SD_RESOLVER);
 
/* Read the measured shaft angle (degrees) and rotational velocity (deg/sec) */
naibrd_SD_GetAngle(cardIndex, module, 1, &angle);
naibrd_SD_GetVelocity(cardIndex, module, 1, &velocity);
 
/* Check the excitation the module sees */
naibrd_SD_GetFrequency(cardIndex, module, 1, &frequency);

/* SSK 2.x */
int32_t maxCh = naibrd_SD_GetChannelCount(modId);
 
/* Configure channel 1 as a resolver input */
naibrd_SD_SetChanMode(cardIndex, module, 1, NAIBRD_SD_RESOLVER);
 
/* Read the measured shaft angle (degrees) and rotational velocity (deg/sec) */
naibrd_SD_GetAngle(cardIndex, module, 1, &angle);
naibrd_SD_GetVelocity(cardIndex, module, 1, &velocity);
 
/* Check the excitation the module sees */
naibrd_SD_GetFrequency(cardIndex, module, 1, &frequency);

To verify the conversion path with no sensor wired, inject a test angle with the D0 internal test (see Confirm communication above).

Run it: SD BasicOps (SSK 2.x) · SD BasicOps (SSK 1.x). For the full set of sample apps — and how to build and run them — see the sample-application guides: Using NAI SSK 2.x Sample Applications · Using NAI SSK 1.x Sample Applications.

Hardware capabilities and status monitoring

This section covers what the SD hardware provides and what you can monitor — for how to drive each operation (with the 1.x/2.x APIs), see Features above.

Hardware capabilities. Every SD module backs those operations with a Type II tracking converter (24-bit angle, 0.1 deg/sec velocity resolution), isolated excitation and signal inputs, a synthetic reference that compensates ±60° of phase shift, programmable bandwidth (2 Hz–1280 Hz, manual or auto), two-speed coarse/fine combining on paired channels, transparent latches for coherent cross-channel snapshots, an extended sample FIFO for post-processing, and power-on + continuous background BIT (each channel checked every 5° to 0.05° accuracy, transparent to normal operation).

Statuses you can monitor programmatically. SD modules expose per-channel status in both real-time (current) and latched (sticky until cleared) forms:

Status	What it tells you	Example constant
Summary	Whether any fault is set on the channel — the single bit to poll	`NAIBRD_SD_CHAN_MAPPED_STATUS_SUMMARY_LATCHED`
BIT	Built-In Test detected a channel accuracy fault	`NAIBRD_SD_CHAN_MAPPED_STATUS_BIT_LATCHED`
Signal fault (low)	Signal voltage below threshold — loss of signal / disconnected sensor	`NAIBRD_SD_CHAN_MAPPED_STATUS_SIGNAL_LATCHED`
Reference fault (low)	Excitation/reference voltage below threshold	`NAIBRD_SD_CHAN_MAPPED_STATUS_REF_LATCHED`
Signal / reference fault (high)	Signal or reference above its over-voltage threshold	`NAIBRD_SD_CHAN_MAPPED_STATUS_SIG_FAULT_HIGH_LATCHED`, `..._REF_FAULT_HIGH_LATCHED`
Two-speed lock loss	Coarse/fine channels lost lock (multi-speed)	`NAIBRD_SD_CHAN_MAPPED_STATUS_2SPDLOCKLOSS_LATCHED`
Open / short	An input line is open or shorted	`NAIBRD_SD_CHAN_MAPPED_STATUS_OPEN_LATCHED`, `..._SHORT_LATCHED`
Delta angle	The angle changed more than the programmed delta (angle alert)	`NAIBRD_SD_CHAN_MAPPED_STATUS_ANGLEDELTA_LATCHED`

Read these per channel with naibrd_SD_GetChanMappedStatus (2.x) / naibrd_SD_GetStatus (1.x), or poll the summary bit to check a channel at a glance. The SD BasicOps sample is built around this status table. ESP2’s status panel shows the same statuses interactively if you’d rather watch them in a GUI first.

Common pitfalls

Angle reads zero (or garbage) on every channel — no sensor or wrong mode. A channel with nothing connected, or set to the wrong mode, reads nonsense. Confirm the wiring, and set naibrd_SD_SetChanMode to resolver for a 4-wire sin/cos sensor or synchro for a 3-wire sensor. To prove the module itself works without a sensor, use the D0 test-angle injection.
Signal- or reference-fault-low status asserted. The signal or excitation voltage is below the threshold — a disconnected lead, a dead excitation source, or a threshold set too high. Check the source; adjust the threshold with naibrd_SD_SetThreshold if appropriate.
Excitation out of band for the model. Each model covers a specific frequency and voltage range. A 400 Hz, 90 V synchro on an SD1 (2–28 V) won’t read correctly — that combination needs SD5. Match the model to your sensor.
Two-speed wiring split across the wrong channels. Coarse/fine pairs are fixed at Ch 1 & 2 and Ch 3 & 4, and you must set the gear Ratio. Wiring a fine resolver to a non-paired channel, or leaving the ratio unset, gives a wrong combined angle.
Velocity or angle looks noisy / lags. The tracking-loop bandwidth is mismatched to the signal. Set it explicitly (naibrd_SD_SetBandwidth) or use auto bandwidth (1/10 of excitation, up to 1280 Hz).
Reading channels at slightly different instants. Use the latch (naibrd_SD_SetLatch) to snapshot all channels simultaneously when you need a coherent set of angles.

DS Family Guide — the mirror-image family that generates synchro/resolver signals (digital-to-synchro/resolver)
LD Family Guide — the linear-displacement cousin that measures LVDT/RVDT
DL Family Guide — the linear-displacement cousin that generates 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_SD_* calls run against
Running Applications from the Target — load and launch a built sample on the board
ESP2 Quick Start — exercise SD channels with no code via the Embedded Soft Panel

NAI Documentation

Explorer

SD Module Guide

SD Family Guide

Overview

SD modules at a glance

Physical setup

Software

Confirm communication

Features

Read a channel — angle, velocity & raw sin/cos

Configure the channel — mode, bandwidth & two-speed

Signal & reference measurement, fault thresholds

Health, BIT & status

Try it

Hardware capabilities and status monitoring

Common pitfalls

Table of Contents

Backlinks

NAI Documentation

Explorer

SD Module Guide

SD Family Guide

Overview

SD modules at a glance

Physical setup

Software

Confirm communication

Features

Read a channel — angle, velocity & raw sin/cos

Configure the channel — mode, bandwidth & two-speed

Signal & reference measurement, fault thresholds

Health, BIT & status

Try it

Hardware capabilities and status monitoring

Common pitfalls

Related resources

Table of Contents

Backlinks