Synchro/Resolver Simulation (D/S & D/R) Family Guide

Overview

The DS family is NAI’s line of Digital-to-Synchro (D/S) and Digital-to-Resolver (D/R) simulation smart function modules. It is the exact mirror image of the SD family: where an SD module reads a synchro/resolver sensor and tells you the shaft angle, a DS module does the reverse — you hand it a digital angle in software and it generates the AC output signals a real synchro or resolver at that angle would produce, at a reference frequency and voltage you choose. There is no shaft and no sensor; the module is the simulated sensor, in solid-state form.

This page is the starting point for any DS or DR module. Use it to understand the family, pick the member that matches the synchro/resolver 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 shaft-angle signals to equipment that consumes synchro/resolver data — without a physical sensor in the loop.

Synchros and resolvers are transformer-type rotary devices: an AC reference (excitation) carrier drives the device, and its output windings return signals whose amplitudes encode the shaft angle. A resolver produces two signals proportional to the sine and cosine of the angle (S1–S3, S2–S4); a synchro produces three line-to-line voltages 120° apart (S1, S2, S3). In both cases the angle lives in the amplitude ratio of AC signals that all oscillate at the reference frequency — a robust, absolute, brushless format that dominates mil-aero position sensing. A DS module synthesizes exactly that signal set electronically, ratiometrically locked to a reference, with no transformers or moving parts.

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

Bench-test or repair the equipment that reads angle — autopilots and flight-control computers, cockpit indicators (attitude, HSI, compass), radar/antenna pedestal controllers, gun/turret drives, and INS/gyro platforms. Instead of building a motor-and-synchro rig to spin to each angle, you command the angle in software: SetAngle(137.5).
Drive hardware-in-the-loop (HIL) simulation — a flight-sim or test computer streams modeled angles in real time, and the DS converts each into live synchro/resolver signals so the real unit-under-test behaves as if it’s flying. The rotation engine and multi-speed (coarse/fine) features exist for exactly this: smooth continuous motion and high-resolution position with no host babysitting.
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 gimbal.
Drive a real receiver — the higher-power models can source enough drive to position an actual synchro torque receiver or remote indicator dial.

(The mirror-image sibling is the SD family, which measures an angle from a real sensor — DS produces the signal, SD reads it; a DS output can drive an SD input for loopback. The linear-position cousin is the LD/LVDT family.)

DS & DR modules at a glance

Every DS/DR module does the same job — turn a digital angle into synchro/resolver output signals — and synchro vs. resolver output format is selectable per channel in software (naibrd_DS_SetSynRslMode), not fixed by the model. The DS/DR naming is the published convention (DS = synchro-format default, DR = resolver-format default); the silicon does both.

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:

1-channel — high power (3 VA/channel): for driving heavier loads (e.g. a torque receiver).

Synchro / Resolver	Output (RMS, L–L)	Output load	Frequency	Manual
DS1 / DR1	2–28 V	3 VA @ 28 V	47 Hz – 1 kHz	DS1-DSN Manual
DS2 / DR2	2–28 V	3 VA @ 28 V	1 – 5 kHz	DS1-DSN Manual
DS3 / DR3	2–28 V	3 VA @ 28 V	5 – 10 kHz	DS1-DSN Manual
DS4 / DR4	2–28 V	3 VA @ 28 V	10 – 20 kHz	DS1-DSN Manual
DS5	28–90 V	3 VA @ 90 V	47 Hz – 1 kHz	DS1-DSN Manual
DSA / DRA	90 V	8 VA @ 90 V	400 Hz	DS1-DSN Manual

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

Synchro / Resolver	Output (RMS, L–L)	Output load	Frequency	Manual
DSB / DRB	2–28 V	1.5 VA @ 28 V	47 Hz – 1 kHz	DS1-DSN Manual
DSC / DRC	2–28 V	1.5 VA @ 28 V	1 – 5 kHz	DS1-DSN Manual
DSD / DRD	2–28 V	1.5 VA @ 28 V	5 – 10 kHz	DS1-DSN Manual
DSE / DRE	2–28 V	1.5 VA @ 28 V	10 – 20 kHz	DS1-DSN Manual
DSJ / DRJ	28–90 V	2.2 VA @ 90 V	47 Hz – 1 kHz	DS1-DSN Manual

3-channel — high density, low power (0.5 VA/channel): ideal for driving solid-state instruments, gauges, and Synchro Booster Amplifiers (SBAs).

Synchro / Resolver	Output (RMS, L–L)	Output load	Frequency	Manual
DSK / DRK	2–28 V	0.5 VA @ 28 V	47 Hz – 1 kHz	DS1-DSN Manual
DSL / DRL	2–28 V	0.5 VA @ 28 V	1 – 5 kHz	DS1-DSN Manual
DSM / DRM	2–28 V	0.5 VA @ 28 V	5 – 10 kHz	DS1-DSN Manual
DSN / DRN	2–28 V	0.5 VA @ 28 V	10 – 20 kHz	DS1-DSN Manual

Note

Single-channel (3 VA) variants are a contact-factory option. A 28–90 V, 0.5 VA 3-channel variant also exists. Always confirm the exact model, channel count, and ranges on the DSx data sheet and the DS1-DSN 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 synchros at low level → a 47 Hz–1 kHz, 2–28 V model; 115 V-class synchros → a 28–90 V model (DS5/DSJ); higher-frequency resolvers → the 1–5 k / 5–10 k / 10–20 k models.
Then match power to the load. Driving a torque receiver or indicator needs the high-power 1-channel (3 VA) or DSA (8 VA) parts; feeding solid-state inputs, gauges, or SBAs is what the 3-channel (0.5 VA) parts are built for; general bench/HIL use fits the 2-channel parts.
Synchro or resolver is not a model choice — every channel can output either format in software (naibrd_DS_SetSynRslMode); the DS/DR label is just the default.

Physical setup

A DS channel is an output: it drives synchro/resolver signals into the equipment (or receiver) you’re feeding. Each channel needs two things wired — the reference (excitation) pair and the signal output lines — plus attention to the model’s drive rating (VA), since unlike a measurement input a DS channel is actually sourcing 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 DS 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 output lines — for a synchro, the three stator lines (S1/S2/S3); for a resolver, the sine pair (S1/S3) and cosine pair (S2/S4).
Connect those output lines to the equipment’s synchro/resolver input (or to a receiver, or to an SD channel for loopback).

A few things hold for every DS module:

Enable the channel and its power before you get output. A channel is silent until you enable it (naibrd_DS_SetChanStatusEnable) and turn on its output power (naibrd_DS_SetPowerEnable). “No output” is almost always one of these two.
Set the output format to match what the equipment expects. Drive a 3-wire synchro input in synchro format, a 4-wire sin/cos input in resolver format (naibrd_DS_SetSynRslMode). The wrong format presents the wrong signals.
Reference: ratio vs. fixed. In ratio mode, the output amplitude tracks an applied reference via a transformation ratio (TR = max output ÷ reference), so the output rides along with whatever excitation the equipment supplies — exactly like a real synchro, and it cancels reference-voltage variation. In fixed mode, the output is an absolute programmed voltage regardless of the reference. The module can also generate its own programmable on-board reference (voltage + frequency) when nothing external drives it. Choose with naibrd_DS_SetRatioFixedMode.
Respect the drive rating. The output sources real power into the load (0.5 / 1.5–2.2 / 3 / 8 VA depending on the model). Driving a torque receiver or indicator needs a high-power part; over-driving a small part trips the over-current status.
Two-speed (coarse/fine) outputs pair adjacent channels. Channel 1 carries the coarse angle and channel 2 the fine angle (coarse × ratio); set the gear ratio with naibrd_DS_SetMultiSpeedRatio on the channel pair.

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

Feed a unit-under-test’s synchro input. Wire the channel’s S1/S2/S3 outputs to the equipment’s synchro input and tie the reference (R1/R2) to the same excitation the equipment uses (ratio mode), or let the module supply the reference (fixed mode). Set synchro format, enable the channel and power, then SetAngle() — the equipment now sees a sensor at that angle.
Loopback to an SD channel. Wire the DS channel’s signal outputs to an SD channel’s signal inputs and share the reference between them. Command an angle on the DS and read it back on the SD — it should match. (This is the cross-family version of the self-test below.)

Software

There’s nothing DS-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 DS module. The only family-specific part is which API functions you call: DS and DR modules both use the naibrd_DS_* calls (there is no separate naibrd_DR_* namespace — the same API drives both formats).

DS 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 DS1-DSN Manual documents every naibrd_DS_* register (angle, expected/threshold voltages, ratio/fixed mode, synchro/resolver format, rotation, multi-speed, BIT, status, measured readback).
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 DS1 module: pull the naibrd_DS_* calls from the DS1-DSN Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch a DS sample on the target per Running Applications from the Target.

Confirm communication

A DS 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. Then, when you want to prove the signals are physically correct, drive a real receiver or an SD channel.

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

/* Bring the channel up and command an angle */
naibrd_DS_SetChanStatusEnable(cardIndex, module, channel, 1);          /* enable the channel */
naibrd_DS_SetPowerEnable(cardIndex, module, channel, NAI_TRUE);        /* turn on output power */
naibrd_DS_SetAngle(cardIndex, module, channel, NAIBRD_DS_ANGLE_SINGLE, 45.0);
 
/* Run the offline initiated self-test (D3 / IBIT): internal stimulus, full-scale range */
bool_t running = NAI_TRUE;
naibrd_DS_SetTestModeEnable(cardIndex, module, NAIBRD_DS_OFF_LINE_TEST, NAI_TRUE);
do { naibrd_DS_GetTestModeEnable(cardIndex, module,
        NAIBRD_DS_OFF_LINE_TEST, &running); } while (running);          /* IBIT clears when done (<30s) */
 
/* Read the latched BIT result for the channel (LO = pass) */
naibrd_ds_module_status_t bitStatus;
naibrd_DS_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_DS_CHAN_MAPPED_STATUS_LATCH_BIT_LOST, &bitStatus);

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

naibrd_DS_SetTestModeEnable(cardIndex, module, NAIBRD_DS_ON_LINE_TEST, NAI_TRUE);
naibrd_DS_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_DS_CHAN_MAPPED_STATUS_REAL_TIME_BIT_LOST, &bitStatus);        /* LO = 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-angle output check (proves the signals are real). Wire the channel’s outputs to a synchro/resolver display, a scope/DMM, or an SD channel (sharing the reference), command a known angle, and confirm it appears:

naibrd_DS_SetSynRslMode(cardIndex, module, channel, NAIBRD_DS_SYNCHRO_MODE);  /* match the receiver */
naibrd_DS_SetAngle(cardIndex, module, channel, NAIBRD_DS_ANGLE_SINGLE, 90.0);
/* On a looped-back SD channel: naibrd_SD_GetAngle(...) should read ~90° */

A receiver that moves to the commanded angle (or an SD that reads it back) confirms the full path end-to-end, including the analog output signals. The DS BasicOps sample drives exactly this flow — angle, voltages, mode, BIT, and status across channels.

Features

Each DS operation works per channel (a few are per module) through the naibrd_DS_* API. The blocks below group the calls by what you’re doing — think of them like the controls on ESP2’s D/S output panel — with the SSK 1.x and 2.x signatures side by side. The function names are the same in both versions; the 1.x → 2.x differences are narrow: enum types renamed nai_ds_* → naibrd_ds_*, out-parameters gained the p_out prefix, and the status calls GetStatus/ClearStatus became per-channel GetChanMappedStatus/ClearChanMappedStatus.

Set & rotate the output angle

What it does / when: the core operation — present a commanded angle on the channel’s output. Set a static angle, or hand off to the rotation engine to sweep the angle automatically at a programmed rate (continuous, or start/stop between two angles) so you can simulate a turning shaft with no host loop.

Applies to: all DS/DR modules.

Also here: NAIBRD_DS_ANGLE_SINGLE sets a single-speed angle, NAIBRD_DS_ANGLE_TWO_SPEED a multi-speed angle, NAIBRD_DS_ANGLE_ROTATION_STOP the rotation stop angle; rotation rate is −1000…1000 °/s and the trigger source can be internal (software) or external.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DS_SetAngle(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_angle_info_type_t type, float64_t inAngle);
nai_status_t naibrd_DS_GetAngle(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_angle_info_type_t type, float64_t *outAngle);
nai_status_t naibrd_DS_SetRotationCtrl(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_rotation_configuration_type_t type, float64_t inRotationCtrl);
nai_status_t naibrd_DS_GetRotationCtrl(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_rotation_configuration_type_t type, float64_t *outRotCtrl);
nai_status_t naibrd_DS_SetRotationEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t inRotEnable);
nai_status_t naibrd_DS_GetRotationStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_rotation_status_t *outStatus);

/* SSK 2.x */
nai_status_t naibrd_DS_SetAngle(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_angle_info_type_t type, float64_t inAngle);
nai_status_t naibrd_DS_GetAngle(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_angle_info_type_t type, float64_t* p_outAngle);
nai_status_t naibrd_DS_SetRotationCtrl(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_rotation_configuration_type_t type, float64_t inRotationCtrl);
nai_status_t naibrd_DS_GetRotationCtrl(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_rotation_configuration_type_t type, float64_t* p_outRotCtrl);
nai_status_t naibrd_DS_SetRotationEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t inRotEnable);
nai_status_t naibrd_DS_GetRotationStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_rotation_status_t* p_outStatus);

Exercise it: DS BasicOps (Angle & Rotation menus) · DS SetAngle · DS Rotation (1.x).

Configure the channel

What it does / when: set up how the angle is presented before (or while) you drive it — output format (synchro vs. resolver), ratio vs. fixed reference handling, the expected signal/reference voltages, the multi-speed ratio for a coarse/fine channel pair, and the channel’s enable and output power.

Applies to: all DS/DR modules. Multi-speed ratio applies to a channel pair (NAIBRD_DS_MULTI_SPD_CH1_2_PAIR).

Also here: NAIBRD_DS_SYNCHRO_MODE / NAIBRD_DS_RESOLVER_MODE select format; NAIBRD_DS_OUTPUT_RATIO / NAIBRD_DS_OUTPUT_FIXED select reference handling; expected voltages use NAIBRD_DS_EXP_VOLT_SIGNAL (VLL) / NAIBRD_DS_EXP_VOLT_REFERENCE (VREF), 0–115 V.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DS_SetSynRslMode(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_synchro_resolver_t inSynRslMode);
nai_status_t naibrd_DS_SetRatioFixedMode(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_output_ratio_fixed_mode_t inRatioFixMode);
nai_status_t naibrd_DS_SetExpectedVoltage(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_expected_voltage_type_t type, float64_t inExpVolt);
nai_status_t naibrd_DS_SetThresholdVoltage(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_threshold_voltage_type_t type, float64_t inThresVolt);
nai_status_t naibrd_DS_SetMultiSpeedRatio(int32_t cardIndex, int32_t module, nai_ds_multi_speed_chan_pair_type_t chanPairType, uint32_t inMultSpd);
nai_status_t naibrd_DS_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t inSetting);
nai_status_t naibrd_DS_SetPowerEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t inPwrEnable);

/* SSK 2.x */
nai_status_t naibrd_DS_SetSynRslMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_synchro_resolver_t inSynRslMode);
nai_status_t naibrd_DS_SetRatioFixedMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_output_ratio_fixed_mode_t inRatioFixMode);
nai_status_t naibrd_DS_SetExpectedVoltage(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_expected_voltage_type_t type, float64_t inExpVolt);
nai_status_t naibrd_DS_SetThresholdVoltage(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_threshold_voltage_type_t type, float64_t inThresVolt);
nai_status_t naibrd_DS_SetMultiSpeedRatio(int32_t cardIndex, int32_t module, naibrd_ds_multi_speed_chan_pair_type_t chanPairType, uint32_t inMultSpd);
nai_status_t naibrd_DS_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t inSetting);
nai_status_t naibrd_DS_SetPowerEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t inPwrEnable);

Exercise it: DS BasicOps (Angle & Multi-Speed menus) · DS SetAngle · DS MultiSpd (1.x).

Measure & monitor the output

What it does / when: the module continuously measures its own output so you can verify it’s driving correctly — measured angle, output (signal) voltage, reference voltage, reference frequency, output current, and velocity. (This is the module watching its own output, not reading an external shaft.)

Applies to: all DS/DR modules; the available measured types vary by generation (current and velocity on the higher-end parts).

Also here: select what to read with the type argument — NAIBRD_DS_MEASURED_ANGLE, _SIGNAL_VOLTAGE, _REF_VOLTAGE, _REF_FREQUENCY, _SIGNAL_CURRENT, _VELOCITY.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DS_GetMeasuredValue(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_measured_Info_type_t type, float64_t *outMeasValue);

/* SSK 2.x */
nai_status_t naibrd_DS_GetMeasuredValue(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_measured_Info_type_t type, float64_t* p_outMeasValue);

Exercise it: DS BasicOps (status row on every menu) · DS SetAngle (1.x).

Health, BIT & status

What it does / when: run the built-in tests and read the channel’s fault flags. D2 / CBIT is the transparent online background test; D3 / IBIT is the offline initiated full-range test; the test verify value sets the D2 comparison reference. The channel-mapped status reports signal-loss, reference-loss, phase-loss, BIT, rotation, and over-current in both real-time and latched forms.

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

Also here: status type values are NAIBRD_DS_CHAN_MAPPED_STATUS_{LATCH,REAL_TIME}_{BIT,SIGNAL,REFERENCE,PHASE,ROTATION}_LOST and _OVR_CURRENT; test types are NAIBRD_DS_ON_LINE_TEST (D2) / NAIBRD_DS_OFF_LINE_TEST (D3). Any of these status events can also drive a hardware interrupt instead of being polled — configure the vector, enable, steering, and trigger (edge/level) with the naibrd_DS_*ChanMappedInterrupt* calls (2.x) / naibrd_DS_SetIntEnable / SetIntVector / SetInterruptSteering / SetInterruptEdgeLevel (1.x).

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DS_SetTestModeEnable(int32_t cardIndex, int32_t module, nai_ds_test_mode_type_t type, bool_t inEnable);
nai_status_t naibrd_DS_GetTestModeEnable(int32_t cardIndex, int32_t module, nai_ds_test_mode_type_t type, bool_t *outEnable);
nai_status_t naibrd_DS_SetTestVerify(int32_t cardIndex, int32_t module, uint32_t inTestVerify);
nai_status_t naibrd_DS_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_status_type_t type, nai_ds_module_status_t *outStatus);
nai_status_t naibrd_DS_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ds_status_type_t type);

/* SSK 2.x */
nai_status_t naibrd_DS_SetTestModeEnable(int32_t cardIndex, int32_t module, naibrd_ds_test_mode_type_t type, bool_t inEnable);
nai_status_t naibrd_DS_GetTestModeEnable(int32_t cardIndex, int32_t module, naibrd_ds_test_mode_type_t type, bool_t* p_outEnable);
nai_status_t naibrd_DS_SetTestVerify(int32_t cardIndex, int32_t module, uint32_t inTestVerify);
nai_status_t naibrd_DS_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_chan_mapped_status_type_t type, naibrd_ds_module_status_t* p_outStatus);
nai_status_t naibrd_DS_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ds_chan_mapped_status_type_t type);

Exercise it: DS BasicOps (BIT Test menu) · DS BITTest · DS Interrupt (Ethernet) (1.x, interrupt-driven status).

Try it

The snippets below show the order of naibrd_DS_* 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 sample apps under each role’s “Exercise it:” line above are the full reference. DS calls are stateless — there is no Open/Init/Free.

Try it — Drive a static angle

Configure the format and reference, enable the channel and its power, then command an angle. Read the module’s own measurement of the output back to confirm.

/* SSK 1.x — drive a single-speed angle */
naibrd_DS_SetSynRslMode(cardIndex, module, channel, NAI_DS_SYNCHRO_MODE);          /* or NAI_DS_RESOLVER_MODE */
naibrd_DS_SetRatioFixedMode(cardIndex, module, channel, NAI_DS_OUTPUT_FIXED);
naibrd_DS_SetExpectedVoltage(cardIndex, module, channel, NAI_DS_EXP_VOLT_SIGNAL, 11.8);     /* VLL */
naibrd_DS_SetExpectedVoltage(cardIndex, module, channel, NAI_DS_EXP_VOLT_REFERENCE, 26.0);  /* VREF */
naibrd_DS_SetChanStatusEnable(cardIndex, module, channel, 1);                      /* enable channel */
naibrd_DS_SetPowerEnable(cardIndex, module, channel, (uint8_t)NAI_ENABLE);         /* output on */
naibrd_DS_SetAngle(cardIndex, module, channel, NAI_DS_ANGLE_SINGLE, 45.0);
 
float64_t measAngle;
naibrd_DS_GetMeasuredValue(cardIndex, module, channel, NAI_DS_MEASURED_ANGLE, &measAngle);

/* SSK 2.x — drive a single-speed angle */
naibrd_DS_SetSynRslMode(cardIndex, module, channel, NAIBRD_DS_SYNCHRO_MODE);          /* or NAIBRD_DS_RESOLVER_MODE */
naibrd_DS_SetRatioFixedMode(cardIndex, module, channel, NAIBRD_DS_OUTPUT_FIXED);
naibrd_DS_SetExpectedVoltage(cardIndex, module, channel, NAIBRD_DS_EXP_VOLT_SIGNAL, 11.8);     /* VLL */
naibrd_DS_SetExpectedVoltage(cardIndex, module, channel, NAIBRD_DS_EXP_VOLT_REFERENCE, 26.0);  /* VREF */
naibrd_DS_SetChanStatusEnable(cardIndex, module, channel, 1);                         /* enable channel */
naibrd_DS_SetPowerEnable(cardIndex, module, channel, NAI_TRUE);                        /* output on */
naibrd_DS_SetAngle(cardIndex, module, channel, NAIBRD_DS_ANGLE_SINGLE, 45.0);
 
float64_t measAngle;
naibrd_DS_GetMeasuredValue(cardIndex, module, channel, NAIBRD_DS_MEASURED_ANGLE, &measAngle);

Try it — Rotate the output

Hand the angle to the rotation engine so it sweeps automatically. Set the trigger source to internal (software), pick continuous mode and a rate, then enable rotation — the output spins at the programmed degrees per second with no host loop. (Start/stop mode and an external trigger are also available; see DS BasicOps.)

/* SSK 1.x — continuous rotation at 100 deg/s */
naibrd_DS_SetChanStatusEnable(cardIndex, module, channel, 1);
naibrd_DS_SetRatioFixedMode(cardIndex, module, channel, NAI_DS_OUTPUT_FIXED);
naibrd_DS_SetRotationCtrl(cardIndex, module, channel, NAI_DS_ROTATION_TRIG_SOURCE, (float64_t)NAI_DS_ROT_TRIG_INTERNAL);
naibrd_DS_SetRotationCtrl(cardIndex, module, channel, NAI_DS_ROTATION_MODE, (float64_t)NAI_DS_ROT_CONTINUOUS_MODE);
naibrd_DS_SetRotationCtrl(cardIndex, module, channel, NAI_DS_ROTATION_RATE, 100.0);
naibrd_DS_SetPowerEnable(cardIndex, module, channel, (uint8_t)NAI_ENABLE);
naibrd_DS_SetRotationEnable(cardIndex, module, channel, TRUE);                 /* spin */

/* SSK 2.x — continuous rotation at 100 deg/s */
naibrd_DS_SetChanStatusEnable(cardIndex, module, channel, 1);
naibrd_DS_SetRatioFixedMode(cardIndex, module, channel, NAIBRD_DS_OUTPUT_FIXED);
naibrd_DS_SetRotationCtrl(cardIndex, module, channel, NAIBRD_DS_ROTATION_TRIG_SOURCE, (float64_t)NAIBRD_DS_ROT_TRIG_INTERNAL);
naibrd_DS_SetRotationCtrl(cardIndex, module, channel, NAIBRD_DS_ROTATION_MODE, (float64_t)NAIBRD_DS_ROT_CONTINUOUS_MODE);
naibrd_DS_SetRotationCtrl(cardIndex, module, channel, NAIBRD_DS_ROTATION_RATE, 100.0);
naibrd_DS_SetPowerEnable(cardIndex, module, channel, NAI_TRUE);
naibrd_DS_SetRotationEnable(cardIndex, module, channel, NAI_TRUE);             /* spin */

Try it — Multi-speed (coarse/fine pair)

Simulate a two-speed (geared) synchro across a channel pair. Set the ratio first, then write the two-speed angle — the module computes the coarse (channel 1) and fine (channel 2 = ratio × coarse) outputs from your single value.

/* SSK 1.x — 36:1 two-speed pair on channels 1 & 2 */
naibrd_DS_SetMultiSpeedRatio(cardIndex, module, NAI_DS_MULTI_SPD_CH1_2_PAIR, 36u);   /* ratio FIRST */
naibrd_DS_SetPowerEnable(cardIndex, module, 1, (uint8_t)NAI_ENABLE);
naibrd_DS_SetPowerEnable(cardIndex, module, 2, (uint8_t)NAI_ENABLE);
naibrd_DS_SetAngle(cardIndex, module, 1, NAI_DS_ANGLE_TWO_SPEED, 45.0);              /* coarse+fine computed */

/* SSK 2.x — 36:1 two-speed pair on channels 1 & 2 */
naibrd_DS_SetMultiSpeedRatio(cardIndex, module, NAIBRD_DS_MULTI_SPD_CH1_2_PAIR, 36u);   /* ratio FIRST */
naibrd_DS_SetPowerEnable(cardIndex, module, 1, NAI_TRUE);
naibrd_DS_SetPowerEnable(cardIndex, module, 2, NAI_TRUE);
naibrd_DS_SetAngle(cardIndex, module, 1, NAIBRD_DS_ANGLE_TWO_SPEED, 45.0);              /* coarse+fine computed */

Note

For resolution beyond a single module, the family also supports multi-speed across multiple boards (MSVMB) — combining coarse and fine channels on different boards into one high-accuracy angle (naibrd_DS_SetMultiSpeedViaMultiBoard). See Multi-Board for that workflow.

Building and running the SSK samples. The snippets above are condensed for orientation. For full, buildable programs see the “Exercise it:” sample-app links under each block in Features — 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 (angle, rotation, multi-speed, configuration), see Features and Try it above.

What the hardware provides:

Solid-state synchro/resolver synthesis — generates the full synchro (3-wire) or resolver (sin/cos) signal set with no transformers or moving parts; format is selectable per channel in software.
Per-channel programmable output — each channel can be set to its own line-to-line voltage and to ratio (output rides the applied reference; TR = max output ÷ reference, cancelling reference-voltage variation) or fixed (absolute) mode.
Programmable on-board reference — the module can source its own excitation (voltage + frequency) when no external reference is applied.
Rotation engine — sweeps the angle continuously or start/stop at a programmed rate, internally or externally triggered.
Multi-speed — coarse/fine channel pairing with a programmable gear ratio (1–255).
Three power tiers — high-power 1-channel (3 VA, up to 8 VA on DSA) for driving torque receivers; 2-channel (1.5–2.2 VA); high-density 3-channel (0.5 VA) for instruments, gauges, and SBAs.
Built-in test — power-on self-test, 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_DS_GetChanMappedStatus):

Status	What it tells you
Signal loss	The output (line-to-line) signal fell below its threshold
Reference loss	The reference/excitation fell below its threshold
Phase loss	Loss of phase lock between output and reference
BIT	A built-in-test fault on the channel (CBIT/IBIT result)
Rotation	Rotation-engine state / rotation lost
Over-current	The channel’s output drive exceeded its current limit (load too heavy)

Measured values — output angle, signal voltage, reference voltage, reference frequency, output current, and velocity — are read with naibrd_DS_GetMeasuredValue (see Measure & monitor the output). ESP2’s D/S panel shows these interactively if you’d rather watch them in a GUI first.

Common pitfalls

No output at all. The channel is silent until you both enable it (naibrd_DS_SetChanStatusEnable) and turn on output power (naibrd_DS_SetPowerEnable). This is the most common “nothing happens.”
Wrong output format. Driving a synchro input in resolver format (or vice-versa) presents the wrong signals. Match naibrd_DS_SetSynRslMode to what the receiving equipment expects.
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 when nothing external supplies a reference, or enable the module’s on-board reference.
Over-driving the load. Each model has a VA limit (0.5 / 1.5–2.2 / 3 / 8 VA). Driving a load heavier than the part supports trips over-current status — use a higher-power tier (or DSA) for torque receivers.
Multi-speed: ratio set after the angle. The fine angle is computed from the coarse angle and the ratio at the moment SetAngle is called — always set the ratio first, then the two-speed angle.
Rotation won’t start. Confirm the rotation mode and trigger source are set, the channel and power are enabled, and (in start/stop mode) the start and stop angles differ.
Expecting GetMeasuredValue to read an external shaft. It reports the module’s own generated output, not a sensor on a wire — DS produces angle, it doesn’t read one. (That’s the SD family.)

DS1-DSN Manual — the D/S & D/R module manual (registers, full naibrd_DS_* API, model table)
SD Family Guide — the mirror-image family that measures synchro/resolver angle
LD Family Guide — the linear-displacement cousin that measures LVDT/RVDT
DL Family Guide — the linear-displacement cousin that generates LVDT/RVDT (DS’s linear counterpart)
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_DS_* calls run against
Running Applications from the Target — load and launch a built sample on the board
DS sample applications — DS BasicOps (2.x) · DS SetAngle · DS Rotation · DS MultiSpd · DS BITTest · DS Interrupt (Ethernet) · Multi-Board (1.x)
ESP2 Quick Start — exercise D/S channels with no code via the Embedded Soft Panel

NAI Documentation

Explorer

DS Module Guide

Synchro/Resolver Simulation (D/S & D/R) Family Guide

Overview

DS & DR modules at a glance

Physical setup

Software

Confirm communication

Features

Set & rotate the output angle

Configure the channel

Measure & monitor the output

Health, BIT & status

Try it

Try it — Drive a static angle

Try it — Rotate the output

Try it — Multi-speed (coarse/fine pair)

Hardware capabilities and status monitoring

Common pitfalls

Table of Contents

Backlinks

NAI Documentation

Explorer

DS Module Guide

Synchro/Resolver Simulation (D/S & D/R) Family Guide

Overview

DS & DR modules at a glance

Physical setup

Software

Confirm communication

Features

Set & rotate the output angle

Configure the channel

Measure & monitor the output

Health, BIT & status

Try it

Try it — Drive a static angle

Try it — Rotate the output

Try it — Multi-speed (coarse/fine pair)

Hardware capabilities and status monitoring

Common pitfalls

Related resources

Table of Contents

Backlinks