AC Reference Family Guide

Overview

The AC family is NAI’s line of programmable AC reference / signal-source smart function modules. Where a DA module produces a precise DC voltage or current, an AC module produces a precise AC signal — you give your software an RMS voltage and a frequency, and the channel sources that AC waveform out, continuously and accurately. Each module has two independent, isolated channels, each voltage- and frequency-programmable across the module’s range, with overcurrent protection and continuous background built-in test.

This page is the starting point for any AC module. Use it to understand the family, pick the member whose voltage and frequency range fits your application, wire a channel to a load, confirm the module is driving, and set your first reference from software. It’s aimed at engineers who need a stable, programmable AC source — an excitation reference, a signal source, or a stimulus output — on an NAI board or system.

In a real system, the AC module’s primary job is to provide the AC excitation reference for synchro, resolver, LVDT, and RVDT devices. Those devices are transformers: a primary winding is excited with an AC reference, and the position is read from how that excitation couples into the secondary windings. The AC module supplies that reference (and can serve as a secondary or backup source, or as a general-purpose programmable AC source on the bench). It is the external excitation companion to NAI’s position families — the resolver-to-digital, resolver simulation, RVDT-to-digital, and RVDT simulation modules all run on an AC reference like this one.

AC modules at a glance

Every AC module gives you two independent, isolated AC reference channels, each programmable for RMS voltage and frequency, with overcurrent protection and continuous background BIT. They differ by the voltage range and frequency band each channel covers:

Module	Channels	Voltage range	Frequency band	Drive
AC2	2	2 – 28 Vrms	47 Hz – 20 kHz	6 VA / 500 mA max
AC3	2	28 – 115 Vrms	47 Hz – 2.5 kHz	6 VA / 52 mA max
AC1	2	CH-1: 2 – 28 Vrms (47 Hz – 20 kHz) CH-2: 28 – 115 Vrms (47 Hz – 2.5 kHz)	—	6 VA

All channels are programmable to 0.01 V and 0.01 Hz resolution. AC1 is an advanced specification — it combines a low-voltage channel and a high-voltage channel on one module; contact the factory for details before designing it in.

Choosing a member:

Low-level excitation (synchro/resolver/LVDT, instrument references) — AC2 (2–28 Vrms, up to 20 kHz). This covers the common 400 Hz and few-kHz aircraft-grade excitation cases.
High-voltage reference (115 Vrms-class synchro/resolver) — AC3 (28–115 Vrms, up to 2.5 kHz).
Both a low- and a high-voltage channel on one module — AC1 (advanced spec, contact factory).

Note

The same AC-reference function is also offered as an optional on-board reference built into many synchro/resolver/LVDT modules (the SD, DS, LD, and DL families). A standalone AC module is what you reach for when you need a separate, secondary, or higher-power source — or AC excitation on a board whose position module wasn’t ordered with the on-board option. There is no combination module that carries an AC reference; every AC module uses the same naibrd_REF_* API described below.

Physical setup

An AC channel is an isolated AC source — once enabled, it drives the programmed RMS voltage at the programmed frequency onto whatever load you wire across that channel’s output. A few things hold for the whole family:

Two terminals plus sense. Each channel brings out an output HI and LO pair. The voltage specs are met at the load when you also connect the channel’s sense lines there — the module uses them to regulate against IR drop in the wiring (regulation is specified “using sense lines”). For a short bench hookup you can tie sense to the output locally; for any real cable run, land sense at the load.
Outputs are isolated from system ground. Each channel floats relative to the chassis/system ground, so you reference it to your load, not to the backplane.
You set it, then you enable it. Programming a voltage or frequency does not energize the output. The channel sources power only after you enable it — and the suggested order is frequency first, then voltage, then enable (see Common pitfalls).
Overcurrent protection latches off. Each channel has a programmable current limit plus a hard, model-dependent limit. Exceeding either disables the channel and sets the overcurrent status; it stays off until you issue a reset. Respect the drive limits (6 VA, and the per-range current ceilings — e.g. 500 mA on the 2–28 V range, ~52 mA on the 28–115 V range).
Mind the frequency band. Pick the member whose band covers your excitation frequency: AC2 reaches 20 kHz, AC3 tops out at 2.5 kHz.

The exact connector pins are per-module, so get them from the manual; the pattern is the same:

Identify the module’s slot number on your NAI motherboard or system.
Bring the channel outputs out through the breakout board, where the slot’s pins appear as generic IO# numbers.
Map IO# pins to each channel’s output HI / LO and sense HI / LO — by the pinout in the module’s manual or the module’s overlay card.
Wire the channel output (and sense) to your load.

A worked example (use your module’s pinout for the actual pins):

Excite a synchro, resolver, or LVDT. Wire the channel’s output HI/LO to the device’s reference (rotor/primary) winding and land the sense lines there too. Program the frequency and RMS voltage the device expects (for example 26 V / 400 Hz or 115 V / 400 Hz), enable the channel, and the device now has its excitation. The position module (SD/LD) reads the resulting signals; a simulation module (DS/DL) drives them.

Software

There’s nothing AC-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 AC module. The only family-specific part is which API functions you call.

Important

AC modules are driven by the naibrd_REF_* (“reference”) API — not a naibrd_AC_* namespace. In the SSK, the AC modules are the reference function: the header is naibrd_ref.h, the calls are naibrd_REF_*, the module IDs are NAIBRD_MODULE_ID_AC1…AC3, and the sample app is ref_basic_ops. If you go looking for naibrd_AC_* you won’t find it.

Each naibrd_REF_* call takes the cardIndex / module / channel coordinates of the channel you’re driving — there’s no separate open/initialize/free step for the module itself; you open the board once (see Opening a Software Handle) and then call the reference functions directly.

Where to find what you need:

Which functions/registers to call — the AC Manual documents every reference register (set voltage/frequency, current limit, channel enable, measured readings, BIT, status, watchdog) behind the naibrd_REF_* calls.
Opening the board from your code — Opening a Software Handle to Your Board covers acquiring the card handle the reference calls run against.
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 AC2 module: pull the naibrd_REF_* calls from the AC Manual, open the board per Opening a Software Handle, set up the ARM Linux toolchain per Connecting to Boards, then load and launch the ref_basic_ops sample on the target per Running Applications from the Target.

Confirm communication

AC gives you two easy first checks, and neither needs a meter or a scope.

1. Built-In Test (zero wiring). Power-On BIT runs automatically at power-up, and the module’s continuous background BIT keeps checking each channel’s voltage, current, and frequency. Reading a passing BIT confirms your board connection, the SSK, and the module are all working — before you wire anything:

bool_t pbitComplete;
nai_status_bit_t bitFailed;
 
naibrd_REF_CheckPowerOnBITComplete(cardIndex, module, &pbitComplete);
if (pbitComplete)
   naibrd_REF_GetChanMappedStatus(cardIndex, module, channel,
                                  NAIBRD_REF_STATUS_BIT_LATCHED, &bitFailed);

If BIT is complete and no channel reports a fault, the module is healthy end-to-end.

2. Set a reference and read back its own measurement. The AC module continuously measures its own output — voltage, frequency, and current — as part of its accuracy monitoring. So you can prove the channel is actually driving by commanding a value, enabling the channel, and reading the measured values back, again with no external equipment:

naibrd_REF_SetData(cardIndex, module, channel, NAIBRD_REF_FREQUENCY, 400.0);  /* 400 Hz */
naibrd_REF_SetData(cardIndex, module, channel, NAIBRD_REF_VOLTAGE,   26.1);   /* 26.1 Vrms */
naibrd_REF_SetChannelEnable(cardIndex, module, channel, 1);                   /* energize */
 
float64_t measV = 0.0, measF = 0.0;
naibrd_REF_GetMeasuredData(cardIndex, module, channel, NAIBRD_REF_MEASURED_VOLTAGE,   &measV);
naibrd_REF_GetMeasuredData(cardIndex, module, channel, NAIBRD_REF_MEASURED_FREQUENCY, &measF);

If the measured voltage and frequency track what you commanded, your board connection, the SSK, and the module are confirmed — and the channel is sourcing a real AC reference. The ref_basic_ops sample exercises all of this interactively (set frequency, set voltage, enable output, and a live measurement display).

Features

Every AC operation works per channel (identified by cardIndex / module / channel) and starts from the standard connection flow — naiapp_RunBoardMenu() then naiapp_query_CardIndex() / naiapp_query_ModuleNumber() give you those coordinates, and naibrd_REF_GetChannelCount(modId) confirms how many reference channels the slot holds (see Opening a Software Handle to Your Board). The blocks below group the calls by what you’re doing, with the SSK 1.x and 2.x signatures side by side. (The 1.x → 2.x rename is visible throughout: the naibrd_REF_SetValueEx / GetValueEx / GetMeasuredValueEx calls became SetData / GetData / GetMeasuredData; the nai_ref_* enum types became naibrd_ref_*; the single GetChannelStatus call split into per-channel GetChanMappedStatus and GetEventMappedStatus; and out-parameters gained the p_out prefix.) For worked, ordered call sequences, see Try it below.

Set the reference — voltage and frequency

What it does: the core operation — program the RMS voltage and the frequency each channel sources. Set both before you enable the channel; the suggested order is frequency, then voltage, then enable.

Applies to: all AC modules, both channels. You pass engineering units (volts, hertz) as a float64_t and select which quantity with the value/data-type argument.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_REF_SetValueEx(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_value_type_t type, float64_t inValue);   /* NAI_REF_VOLTAGE / NAI_REF_FREQUENCY */
nai_status_t naibrd_REF_GetValueEx(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_value_type_t type, float64_t* outValue);

/* SSK 2.x */
nai_status_t naibrd_REF_SetData(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_data_type_t type, float64_t data);        /* NAIBRD_REF_VOLTAGE / NAIBRD_REF_FREQUENCY */
nai_status_t naibrd_REF_GetData(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_data_type_t type, float64_t* p_outdata);

Exercise it: REF Basic Ops (FREQ, VOLT).

Enable the output and protect it

What it does: energize or de-energize a channel, set its programmable current limit, and clear an overcurrent trip. A channel that exceeds its current limit (or the hard, model-dependent limit) disables itself and latches the overcurrent status — you re-enable it with a reset.

Applies to: all AC modules, both channels.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_REF_SetChannelEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t inValue);   /* 1 = on, 0 = off */
nai_status_t naibrd_REF_GetChannelEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* outValue);
nai_status_t naibrd_REF_SetValueEx(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_value_type_t type, float64_t inValue);   /* NAI_REF_CURRENT_LIMIT */
nai_status_t naibrd_REF_SetReset(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_reset_type_t type);       /* NAI_REF_RESET_OVERCURRENT */
nai_status_t naibrd_REF_SetResetAll(int32_t cardIndex, int32_t module, nai_ref_reset_type_t type);

/* SSK 2.x */
nai_status_t naibrd_REF_SetChannelEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t value);   /* 1 = on, 0 = off */
nai_status_t naibrd_REF_GetChannelEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* p_outvalue);
nai_status_t naibrd_REF_SetData(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_data_type_t type, float64_t data);   /* NAIBRD_REF_CURRENT_LIMIT */
nai_status_t naibrd_REF_SetReset(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_reset_type_t type);    /* NAIBRD_REF_RESET_OVERCURRENT */
nai_status_t naibrd_REF_SetResetAll(int32_t cardIndex, int32_t module, naibrd_ref_reset_type_t type);

Exercise it: REF Basic Ops (POWR, C_LIMIT, RCHAN).

Measure its own output

What it does: read the channel’s actual measured voltage, frequency, and current — the values the module monitors continuously for accuracy. Optionally turn on hardware floating-point mode so the module does the integer↔float conversion itself instead of your CPU.

Applies to: all AC modules. Floating-point mode is a module-wide setting; wait for it to take effect before writing/reading values (see Common pitfalls).

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_REF_GetMeasuredValueEx(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_measured_type_t type, float64_t* outValue);   /* NAI_REF_MEASURED_VOLTAGE / _FREQUENCY / _CURRENT */
nai_status_t naibrd_SetFloatingPointModeEnable(int32_t cardIndex, int32_t module, bool_t enable);
nai_status_t naibrd_GetRunningInFloatingPointMode(int32_t cardIndex, int32_t module, bool_t* outEnable);

/* SSK 2.x */
nai_status_t naibrd_REF_GetMeasuredData(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_measured_type_t type, float64_t* p_outdata);   /* NAIBRD_REF_MEASURED_VOLTAGE / _FREQUENCY / _CURRENT */
nai_status_t naibrd_SetFloatingPointModeEnable(int32_t cardIndex, int32_t module, bool_t enable);
nai_status_t naibrd_GetRunningInFloatingPointMode(int32_t cardIndex, int32_t module, bool_t* p_outEnable);

Exercise it: REF Basic Ops (live measurement display, FP).

Health, BIT, and status

What it does: confirm power-on BIT, monitor each channel’s faults — BIT, overcurrent, voltage out-of-spec, frequency out-of-spec, watchdog, and the rolled-up summary — and mask channels you aren’t using. In 1.x a single GetChannelStatus call selects the fault type and the latched/realtime access; 2.x splits this into GetChanMappedStatus (BIT, summary, watchdog) and GetEventMappedStatus (overcurrent, voltage, frequency), with latched/realtime folded into the status-type enum.

Applies to: all AC modules.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_REF_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_REF_GetChannelStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_status_type_t type, nai_ref_status_access_type_t accessType, uint32_t* outStatus);
nai_status_t naibrd_REF_ClearChannelStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ref_status_type_t type);
nai_status_t naibrd_REF_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

/* SSK 2.x */
nai_status_t naibrd_REF_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outpbitComplete);
nai_status_t naibrd_REF_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_chan_mapped_status_type_t statusType, nai_status_bit_t* p_outstatusBit);     /* BIT / SUMMARY / WATCHDOG_TIMER_FAULT, _LATCHED or _REALTIME */
nai_status_t naibrd_REF_GetEventMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_event_mapped_status_type_t statusType, nai_status_bit_t* p_outstatusBit);   /* OVERCURRENT / VOLTAGE / FREQUENCY, _LATCHED or _REALTIME */
nai_status_t naibrd_REF_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ref_chan_mapped_status_type_t statusType);
nai_status_t naibrd_REF_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

Exercise it: REF Basic Ops (PBIT, CHANSTAT) · REF Summary.

Try it

Three short sequences that put the Features together. Each is shown for both SSK versions; all use the cardIndex / module coordinates from your board open, and channel 1 as an example.

1. Bring up a reference and confirm it. Set frequency, then voltage, then enable — and read the module’s own measurement back:

/* SSK 1.x */
int32_t ch = 1;
float64_t measV = 0.0, measF = 0.0;
 
naibrd_REF_SetValueEx(cardIndex, module, ch, NAI_REF_FREQUENCY, 400.0);   /* 400 Hz first */
naibrd_REF_SetValueEx(cardIndex, module, ch, NAI_REF_VOLTAGE,   26.1);    /* then 26.1 Vrms */
naibrd_REF_SetChannelEnable(cardIndex, module, ch, 1);                    /* energize */
 
naibrd_REF_GetMeasuredValueEx(cardIndex, module, ch, NAI_REF_MEASURED_VOLTAGE,   &measV);
naibrd_REF_GetMeasuredValueEx(cardIndex, module, ch, NAI_REF_MEASURED_FREQUENCY, &measF);

/* SSK 2.x */
int32_t ch = 1;
float64_t measV = 0.0, measF = 0.0;
 
naibrd_REF_SetData(cardIndex, module, ch, NAIBRD_REF_FREQUENCY, 400.0);   /* 400 Hz first */
naibrd_REF_SetData(cardIndex, module, ch, NAIBRD_REF_VOLTAGE,   26.1);    /* then 26.1 Vrms */
naibrd_REF_SetChannelEnable(cardIndex, module, ch, 1);                    /* energize */
 
naibrd_REF_GetMeasuredData(cardIndex, module, ch, NAIBRD_REF_MEASURED_VOLTAGE,   &measV);
naibrd_REF_GetMeasuredData(cardIndex, module, ch, NAIBRD_REF_MEASURED_FREQUENCY, &measF);

2. Set a current limit and recover from an overcurrent trip. Cap the channel’s current; if a load fault disables it, clear the trip and re-energize:

/* SSK 1.x */
uint32_t enabled = 0;
naibrd_REF_SetValueEx(cardIndex, module, ch, NAI_REF_CURRENT_LIMIT, 100.0);   /* 100 mA limit */
 
naibrd_REF_GetChannelEnable(cardIndex, module, ch, &enabled);
if (!enabled)   /* an overload latched the channel off */
{
   naibrd_REF_SetReset(cardIndex, module, ch, NAI_REF_RESET_OVERCURRENT);     /* clear the trip */
   naibrd_REF_ClearChannelStatus(cardIndex, module, ch, NAI_REF_STATUS_OVERCURRENT);
   naibrd_REF_SetChannelEnable(cardIndex, module, ch, 1);                     /* re-energize */
}

/* SSK 2.x */
uint32_t enabled = 0;
naibrd_REF_SetData(cardIndex, module, ch, NAIBRD_REF_CURRENT_LIMIT, 100.0);   /* 100 mA limit */
 
naibrd_REF_GetChannelEnable(cardIndex, module, ch, &enabled);
if (!enabled)   /* an overload latched the channel off */
{
   naibrd_REF_SetReset(cardIndex, module, ch, NAIBRD_REF_RESET_OVERCURRENT);  /* clear the trip */
   naibrd_REF_ClearEventMappedStatus(cardIndex, module, ch, NAIBRD_REF_STATUS_OVERCURRENT_LATCHED);
   naibrd_REF_SetChannelEnable(cardIndex, module, ch, 1);                     /* re-energize */
}

3. Offload conversion to hardware floating-point mode. Enable it, then wait for the module to report it’s running before you write or read values:

/* SSK 1.x */
bool_t fpRunning = NAI_FALSE;
naibrd_SetFloatingPointModeEnable(cardIndex, module, NAI_TRUE);
do {
   naibrd_GetRunningInFloatingPointMode(cardIndex, module, &fpRunning);
} while (!fpRunning);   /* wait until the module finishes converting its registers */
 
naibrd_REF_SetValueEx(cardIndex, module, ch, NAI_REF_VOLTAGE, 26.1);   /* now exchanged as IEEE-754 */

/* SSK 2.x */
bool_t fpRunning = NAI_FALSE;
naibrd_SetFloatingPointModeEnable(cardIndex, module, NAI_TRUE);
do {
   naibrd_GetRunningInFloatingPointMode(cardIndex, module, &fpRunning);
} while (!fpRunning);   /* wait until the module finishes converting its registers */
 
naibrd_REF_SetData(cardIndex, module, ch, NAIBRD_REF_VOLTAGE, 26.1);   /* now exchanged as IEEE-754 */

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 — REF Basic Ops (all of the above, interactively) · REF Summary (the SSK 1.x equivalent is REF_BasicOps) — 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

Beyond setting a voltage and frequency, each AC module gives you:

Two isolated reference channels, each independently programmable for RMS voltage and frequency (0.01 V / 0.01 Hz resolution), floating relative to system ground.
Continuous accuracy monitoring — the module constantly measures its own output voltage, current, and frequency, which is what makes the read-back self-test possible and feeds the out-of-spec detections.
Overcurrent protection — a programmable per-channel current limit plus a hard, model-dependent limit; either one disables the channel and latches an overcurrent status until you reset it.
Continuous background BIT — each channel is checked for correct voltage, current, and frequency. BIT uses an “add-2, subtract-1” counting scheme with a programmable threshold (specified in milliseconds) so brief, intermittent anomalies don’t raise false faults.
User watchdog timer — an optional watchdog the host strobes to prove it’s alive (see the pitfall about what happens if strobing stops).
Hardware floating-point mode — offloads integer↔IEEE-754 conversion from your CPU to the module.

Statuses you can monitor:

Status	What it tells you	Access
BIT	A channel failed its built-in voltage/current/frequency check	Latched + realtime, per channel
Overcurrent	Output exceeded the current limit; the channel has been disabled	Latched + realtime, per channel
Voltage out-of-spec	Measured voltage fell outside the set value’s tolerance (channel stays on)	Latched + realtime, per channel
Frequency out-of-spec	Measured frequency fell outside the set value’s tolerance (channel stays on)	Latched + realtime, per channel
Watchdog timer fault	The user watchdog was not strobed in time	Latched + realtime, per channel
Summary	Rolled-up “something is wrong on this channel” indicator	Latched + realtime, per channel
Module power reset	Module-level state: powered down, not detected, link not initialized, firmware not ready, comm error	Module level

Use SetChanStatusEnable to mask channels you aren’t using so their bits don’t show up in the summary. Any of these can also raise an interrupt (1.x exposes the naibrd_REF_SetInterrupt* calls for vector/steering/edge-level control).

Common pitfalls

Set frequency and voltage before you enable the channel. Enabling first can drive the wrong waveform briefly. The module’s own suggested sequence is frequency → voltage → enable.
An overcurrent trip latches the channel off. Once a channel exceeds its current limit (or the hard limit), it disables itself and stays off — calling SetChannelEnable(…, 1) again does nothing until you first issue SetReset(…, RESET_OVERCURRENT) and clear the overcurrent status. Fix the load before re-enabling.
The user watchdog will shut the module down if you stop strobing it. If you enable the watchdog and the strobe stops — the strobing thread exits, the app crashes, you quit the sample — the module shuts off all outputs and must be power-cycled to recover. Only enable the watchdog when you have a reliable, continuous strobe; otherwise leave it off.
Wait for floating-point mode to engage. After calling SetFloatingPointModeEnable, poll GetRunningInFloatingPointMode (the Floating Point State register) until it matches the requested mode before writing or reading values — otherwise registers may hold the wrong binary representation and generate false faults.
Match the frequency to the member’s band. AC2 reaches 20 kHz; AC3 tops out at 2.5 kHz. Don’t program a frequency outside the member’s range.
Use the sense lines for anything but a short hookup. Regulation is specified at the load using the sense lines; skip them on a real cable run and you’ll see voltage droop under load.
It’s the naibrd_REF_* API. Worth repeating: there is no naibrd_AC_* namespace — the AC modules are the SSK’s reference function (naibrd_ref.h, module IDs NAIBRD_MODULE_ID_AC1…AC3).

AC Manual — full register and specification reference for AC1/AC2/AC3
SD Family Guide — synchro/resolver-to-digital; measures angle from a device the AC module excites
DS Family Guide — synchro/resolver simulation; generates synchro/resolver signals
LD Family Guide — LVDT/RVDT-to-digital; measures displacement from an AC-excited device
DL Family Guide — LVDT/RVDT simulation; generates LVDT/RVDT signals
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_REF_* calls run against
Running Applications from the Target — load and launch a built sample on the board
ESP2 Quick Start — browse and exercise modules with no code via the Embedded Soft Panel

NAI Documentation

Explorer

AC Module Guide

AC Reference Family Guide

Overview

AC modules at a glance

Physical setup

Software

Confirm communication

Features

Set the reference — voltage and frequency

Enable the output and protect it

Measure its own output

Health, BIT, and status

Try it

Hardware capabilities and status monitoring

Common pitfalls

Table of Contents

NAI Documentation

Explorer

AC Module Guide

AC Reference Family Guide

Overview

AC modules at a glance

Physical setup

Software

Confirm communication

Features

Set the reference — voltage and frequency

Enable the output and protect it

Measure its own output

Health, BIT, and status

Try it

Hardware capabilities and status monitoring

Common pitfalls

Related resources

Table of Contents