CD Module Guide

Chip Detector & Fuzz Burn Family Guide

Overview

The CD family is NAI’s line of chip-detector and fuzz-burn smart function modules — condition-monitoring modules that watch a mechanical system for impending failure. A chip detector is a magnetic sensor that sits in the lubrication (oil) system of a gearbox, bearing, or engine. As gears and bearings wear, they shed metallic debris into the oil; the magnet attracts that debris, and as ferrous particles bridge the gap between the sensor’s two contacts, the resistance across the sensor drops. The CD module continuously measures that resistance on each channel and flags warning and fault conditions against thresholds you program.

The catch is that normal wear produces fine metallic “fuzz” that bridges the contacts and looks just like the early stage of a real failure — so a naive chip detector throws constant false alarms. The CD module’s answer is fuzz burn: a programmable capacitor discharge that “burns off” the harmless fuzz across the contacts. If the resistance recovers after a burn, it was just fuzz; if it stays low after repeated burns, there’s a real chip and the module flags a fault. This lets a system distinguish a genuine impending failure from nuisance fuzz — the difference between a meaningful cockpit chip-detect indication and an alert the crew learns to ignore.

This page is the starting point for any CD module. Use it to understand the family, wire a chip-detector sensor to a channel, confirm the module is healthy, set your detection thresholds, and run your first manual or automatic fuzz burn. It’s aimed at engineers integrating engine/gearbox/transmission health and usage monitoring (HUMS)-style chip detection on an NAI board or system.

CD modules at a glance

Every CD module is a standard NAI COSA® smart function providing independent, isolated chip-detect + fuzz-burn channels. Each channel measures sensor resistance, compares it against three programmable thresholds, and can fire a programmable-energy burn either automatically or on command. They differ by channel count:

Module	Channels	Notable
CD1	6	Independent, isolated CD/FB channels; 0.25–2.30 J programmable burn energy; Auto/Manual burn

All CD members share the same naibrd_CD_* API; the only family-specific value is the channel count (and the all-channels bitmask, e.g. NAIBRD_CD1_ALL_CHANNELS_MASK = 0x3F for CD1’s six channels), which you read at runtime with naibrd_CD_GetChannelCount().

How chip detection & fuzz burn works

Since everything on a CD module hinges on one measurement — sensor resistance — it’s worth being precise about how the pieces relate before wiring anything.

The measurement. Each channel continuously measures the resistance across its chip-detector sensor, from 0 to 100 kΩ (most accurate below ~8 kΩ, where real detections live). High resistance means a clean gap; resistance falls as conductive debris bridges the contacts.

Three thresholds, ordered low-to-high — 0 < FAULT < WARN < OPEN:

Threshold	Set when resistance is…	Meaning
Fault	at or below the fault threshold	Significant bridging — the primary trigger for an auto-burn
Warning	below the warning threshold	Debris building up; approaching fault
Open	above the open threshold	Open circuit — broken wire or disconnected sensor (use a parallel monitor resistor so an open harness reads as “too high”)

As debris accumulates, a channel crosses Warning then Fault on the way down; a disconnected sensor reads above Open.

The burn. When a burn fires, the module delivers a programmed energy pulse (0.25–2.30 J, a SEPIC-regulated capacitor discharge that’s independent of input-voltage fluctuations) across the contacts to clear the fuzz. A safety interlock suppresses all burn triggers — every threshold setting and both burn modes — whenever the measured resistance is above 2 kΩ: if there’s no low-resistance bridge, there’s nothing to burn.

Auto vs. manual:

• Auto-burn — you arm the channel with warning/fault thresholds and a maximum burn count; the module fires automatically when resistance reaches the fault threshold and keeps re-burning until the resistance recovers above the warning threshold or the max count is hit. If a burn succeeds and resistance rises above warning, the burn count automatically resets and the channel re-arms — no host intervention.
• Manual-burn — you watch the resistance yourself and trigger each burn on demand (still subject to the 2 kΩ suppression).

Physical setup

A CD channel is an independent, isolated resistance-measurement + burn circuit. You wire each channel to one chip-detector sensor installed in the monitored gearbox/engine oil system. A few things hold for the family:

• Per-channel isolation. Each channel’s measurement circuit is independent and isolated from system ground, which mitigates false triggers and cross-channel coupling.
• Open-wire detection. Wire a monitor resistor in parallel with the sensor and set the Open threshold above it, so a broken harness or disconnected sensor reads as an open (resistance above the Open threshold) rather than silently looking “clean.”
• Power. The burn circuit runs from the +28 V input per MIL-STD-704 (full operating range and transients); the programmable burn energy is regulated independent of input-voltage fluctuations.
• Burn delivers energy. A fuzz burn discharges a programmed energy pulse into the connected circuit — verify channel assignments, energy settings, and wiring, and confirm with test loads before connecting live sensors.

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

1. Identify the module’s slot number on your NAI motherboard or system.
2. Bring the channel’s sensor connections out through the breakout board, where the slot’s pins appear as generic IO# numbers.
3. Map IO# pins to each channel’s sensor and return — by the pinout in the module’s manual or the module’s overlay card.
4. Wire each channel to its chip-detector sensor (with a parallel monitor resistor for open detection).

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

• Monitor a gearbox channel. Wire a channel to its chip-detector sensor, set the warning/fault/open thresholds for that gearbox, enable the channel, and read the resistance and status as the system runs.
• Bench-confirm a channel with a test load. Wire a known resistor (and a parallel monitor resistor) to a channel, set thresholds around the resistor’s value, and confirm the channel reports the expected warning/fault/open status before connecting a live sensor.

Software

There’s nothing CD-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 CD module. The only family-specific part is which API functions you call: CD modules use the naibrd_CD_* calls, each taking the cardIndex / module (and, for per-channel calls, channel) coordinates of the channel you’re working with.

Note

The CD API is SSK 2.x. The CD sample applications are new to SSK 2.x and have no SSK 1.x counterpart.

CD calls are stateless — there is no Open/Init/Free lifecycle. You read the connection coordinates once from the standard board menu and then pass them to each call.

Where to find what you need:

• Which functions/registers to call — the CD1 Manual documents every CD register (channel enable, resistance, the three thresholds, energy, burn mode/count, BIT, status) and the naibrd_CD_* API.
• 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 CD1 module: pull the naibrd_CD_* calls from the CD1 Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch a CD sample on the target per Running Applications from the Target.

Confirm communication

CD gives you an easy first check: Built-In Test. The module’s BIT charges and discharges its burn circuitry against an on-board load and verifies the discharge profile, so a passing BIT confirms the measurement and burn hardware are healthy — no external sensor required. That makes BIT the fastest way to confirm your board connection, the SSK, and the module are all working.

Power-On BIT runs automatically at power-up. Check that it completed, then read the BIT result:

bool_t pbitComplete;
nai_status_bit_t bitFailed;
 
naibrd_CD_CheckPowerOnBITComplete(cardIndex, module, &pbitComplete);
if (pbitComplete)
   /* BIT coverage is module-wide; the channel argument is not significant —
      if one channel fails BIT, all channels report the failure. */
   naibrd_CD_GetChanMappedStatus(cardIndex, module, channel,
                                 NAIBRD_CD_STATUS_BIT_LATCHED, &bitFailed);

If PBIT is complete and BIT reports no failure, the module is healthy end-to-end. To also confirm the measurement path, enable a channel and read its resistance with a known test load wired up:

naibrd_CD_SetEnabledChannels(cardIndex, module, NAIBRD_CD1_ALL_CHANNELS_MASK);
 
int32_t resistance;
naibrd_CD_GetChanResistance(cardIndex, module, channel, &resistance);   /* ohms */

If the channel reads the resistance you expect for your test load, your board connection, the SSK, and the module are confirmed. The CD Basic Ops sample exercises all of this interactively.

Features

Every CD operation works from the standard connection flow — naiapp_RunBoardMenu() then naiapp_query_CardIndex() / naiapp_query_ModuleNumber() give you the cardIndex / module coordinates, and naibrd_CD_GetChannelCount() confirms the slot holds a CD module and tells you how many channels it has (see Opening a Software Handle to Your Board). The blocks below group the calls by what you’re doing. For worked, ordered call sequences, see Try it below.

Note the two addressing styles in the API: channel-bitmap calls act on several channels at once (a hex mask where bit 0 = channel 1, so 0x3F = all six CD1 channels), while per-channel calls take a single channel number.

Enable channels & measure resistance

What it does: turn channels on and read the live sensor resistance — the core measurement everything else is built on. Enabling is a channel bitmap; reading resistance is per channel.

Applies to: all CD modules.

Relevant APIs:

int32_t      naibrd_CD_GetChannelCount(uint32_t modId);
nai_status_t naibrd_CD_SetEnabledChannels(int32_t cardIndex, int32_t module, uint32_t channels);
nai_status_t naibrd_CD_GetEnabledChannels(int32_t cardIndex, int32_t module, uint32_t* p_outEnabledChannels);
nai_status_t naibrd_CD_GetChanResistance(int32_t cardIndex, int32_t module, int32_t channel, int32_t* p_outResistance);

Exercise it: CD Basic Ops (Enable Channels, Get Enabled Channels, Get Channel Resistance).

Set detection thresholds

What it does: program the three per-channel resistance thresholds that define Warning, Fault, and Open status (0 < Fault < Warn < Open). These set when status bits assert and, in auto-burn, when a burn fires and when it stops.

Applies to: all CD modules.

Relevant APIs:

nai_status_t naibrd_CD_SetChanFaultResistanceThreshold(int32_t cardIndex, int32_t module, int32_t channel, int32_t threshold);
nai_status_t naibrd_CD_GetChanFaultResistanceThreshold(int32_t cardIndex, int32_t module, int32_t channel, int32_t* p_outThreshold);
nai_status_t naibrd_CD_SetChanWarningResistanceThreshold(int32_t cardIndex, int32_t module, int32_t channel, int32_t threshold);
nai_status_t naibrd_CD_GetChanWarningResistanceThreshold(int32_t cardIndex, int32_t module, int32_t channel, int32_t* p_outThreshold);
nai_status_t naibrd_CD_SetChanOpenResistanceThreshold(int32_t cardIndex, int32_t module, int32_t channel, int32_t threshold);
nai_status_t naibrd_CD_GetChanOpenResistanceThreshold(int32_t cardIndex, int32_t module, int32_t channel, int32_t* p_outThreshold);

Exercise it: CD Basic Ops (Set/Get Channel Fault, Warning, and Open Resistance).

Fuzz burn — manual & auto

What it does: set per-channel burn energy and fire a burn. Manual burn fires once per command; auto burn arms the channel to fire automatically against the fault threshold, re-burning up to a maximum count until the resistance recovers. Initiation and the burn-channel queries are channel bitmaps; energy and the count values are per channel. (All burns are suppressed while resistance is above 2 kΩ.)

Applies to: all CD modules.

Relevant APIs:

nai_status_t naibrd_CD_SetChanEnergySetting(int32_t cardIndex, int32_t module, int32_t channel, float32_t energySetting);   /* 0.25–2.30 J */
nai_status_t naibrd_CD_GetChanEnergySetting(int32_t cardIndex, int32_t module, int32_t channel, float32_t* p_outEnergySetting);
 
nai_status_t naibrd_CD_InitiateManualBurnChannels(int32_t cardIndex, int32_t module, uint32_t channels);
nai_status_t naibrd_CD_GetManualBurnChannels(int32_t cardIndex, int32_t module, uint32_t* p_outChannels);
 
nai_status_t naibrd_CD_InitiateAutoBurnChannels(int32_t cardIndex, int32_t module, uint32_t channels);
nai_status_t naibrd_CD_GetAutoBurnChannels(int32_t cardIndex, int32_t module, uint32_t* p_outChannels);
nai_status_t naibrd_CD_SetAutoBurnMaxCount(int32_t cardIndex, int32_t module, int32_t channel, uint32_t maxCount);   /* default 3; up to 10 */
nai_status_t naibrd_CD_GetAutoBurnMaxCount(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* p_outMaxCount);
nai_status_t naibrd_CD_GetAutoBurnCount(int32_t cardIndex, int32_t module, int32_t channel, uint32_t* p_outCount);

Exercise it: CD Basic Ops (Set Energy, Initiate Manual/Auto Burn, Auto Burn Max Count/Count) · CD Manual and Auto Burn (the full manual-vs-auto workflow with status monitoring).

Health, status & BIT

What it does: enable per-channel status reporting, read Warning/Fault/Open and BIT status, and run/tune Built-In Test. GetChanMappedStatus reads a single channel’s status bit; GetChanMappedStatusRaw returns the bitmap across all channels for a given status type.

Applies to: all CD modules. (BIT coverage is module-wide.)

Relevant APIs:

nai_status_t naibrd_CD_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_CD_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_cd_chan_mapped_status_type_t statusType, nai_status_bit_t* p_outStatusBit);
nai_status_t naibrd_CD_GetChanMappedStatusRaw(int32_t cardIndex, int32_t module, naibrd_cd_chan_mapped_status_type_t statusType, uint32_t* p_outStatusRaw);
 
nai_status_t naibrd_CD_SetModuleBITEnable(int32_t cardIndex, int32_t module, naibrd_cd_test_type_t testType, bool_t enable);
nai_status_t naibrd_CD_GetModuleBITEnable(int32_t cardIndex, int32_t module, naibrd_cd_test_type_t testType, bool_t* p_outEnabled);
nai_status_t naibrd_CD_CheckPowerOnBITComplete(int32_t cardIndex, int32_t module, bool_t* p_outPbitComplete);
nai_status_t naibrd_CD_SetModuleBITErrorThreshold(int32_t cardIndex, int32_t module, uint32_t threshold);
nai_status_t naibrd_CD_GetModuleBITErrorThreshold(int32_t cardIndex, int32_t module, uint32_t* p_outThreshold);
nai_status_t naibrd_CD_ClearModuleBITLogic(int32_t cardIndex, int32_t module);

The status types (naibrd_cd_chan_mapped_status_type_t) include NAIBRD_CD_STATUS_FAULT_RES_REALTIME / _LATCHED, NAIBRD_CD_STATUS_WARN_RES_REALTIME / _LATCHED, NAIBRD_CD_STATUS_OPEN_RES_REALTIME / _LATCHED, and NAIBRD_CD_STATUS_BIT_LATCHED. The BIT test types (naibrd_cd_test_type_t) are NAIBRD_CD_D0_TEST and NAIBRD_CD_D3_TEST.

Exercise it: CD Basic Ops (Set/Get Module BIT Enable, Check Module PBIT Complete, Manipulate BIT Error Thresholds) · CD Manual and Auto Burn (status-monitoring loop).

Try it

The snippets below show the order of naibrd_CD_* 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 test. Each is the conceptual sequence, not a fully-buildable program; the sample apps under each block’s “Exercise it:” line above are the full reference. CD calls are stateless — there is no Open/Init/Free.

Try it — Measure resistance and set thresholds

Enable the channel, program the three thresholds, then read the live resistance and status.

/* Enable channels (bitmap: 0x3F = all six CD1 channels) */
naibrd_CD_SetEnabledChannels(cardIndex, module, NAIBRD_CD1_ALL_CHANNELS_MASK);
 
/* Program thresholds for this channel (ohms): 0 < Fault < Warn < Open */
naibrd_CD_SetChanFaultResistanceThreshold(cardIndex, module, channel, 150);
naibrd_CD_SetChanWarningResistanceThreshold(cardIndex, module, channel, 1000);
naibrd_CD_SetChanOpenResistanceThreshold(cardIndex, module, channel, 13000);
 
/* Turn on status reporting and read resistance + status */
naibrd_CD_SetChanStatusEnable(cardIndex, module, channel, NAI_TRUE);
 
int32_t resistance;
nai_status_bit_t faultBit;
naibrd_CD_GetChanResistance(cardIndex, module, channel, &resistance);
naibrd_CD_GetChanMappedStatus(cardIndex, module, channel,
                              NAIBRD_CD_STATUS_FAULT_RES_REALTIME, &faultBit);

Try it — Manual fuzz burn

Set the burn energy, then fire a single burn across a channel bitmap and confirm which channels burned. (The burn only fires if the measured resistance is at or below the 2 kΩ suppression threshold.)

/* Energy in Joules (0.25–2.30); a 0.003" wire typically needs ~0.6 J */
naibrd_CD_SetChanEnergySetting(cardIndex, module, channel, 1.25f);
 
/* Fire a manual burn on the selected channels (bit 0 = channel 1) */
uint32_t channelMask = (1u << (channel - 1));
naibrd_CD_InitiateManualBurnChannels(cardIndex, module, channelMask);
 
uint32_t burning;
naibrd_CD_GetManualBurnChannels(cardIndex, module, &burning);   /* which channels are actively burning */

Try it — Auto fuzz burn with status monitoring

Program thresholds and energy, set a maximum burn count, arm auto-burn, then poll the per-channel status and burn count as the module fires automatically.

/* Per channel: thresholds, energy, and max burn count */
naibrd_CD_SetChanFaultResistanceThreshold(cardIndex, module, channel, 150);
naibrd_CD_SetChanWarningResistanceThreshold(cardIndex, module, channel, 1000);
naibrd_CD_SetChanOpenResistanceThreshold(cardIndex, module, channel, 13000);
naibrd_CD_SetChanEnergySetting(cardIndex, module, channel, 1.25f);
naibrd_CD_SetAutoBurnMaxCount(cardIndex, module, channel, 3);
naibrd_CD_SetChanStatusEnable(cardIndex, module, channel, NAI_TRUE);
 
/* Arm auto-burn across the channel bitmap and enable the channels */
naibrd_CD_InitiateAutoBurnChannels(cardIndex, module, NAIBRD_CD1_ALL_CHANNELS_MASK);
naibrd_CD_SetEnabledChannels(cardIndex, module, NAIBRD_CD1_ALL_CHANNELS_MASK);
 
/* Poll status (bitmaps across channels) and per-channel burn count */
uint32_t faultRaw, autoBurnCount;
naibrd_CD_GetChanMappedStatusRaw(cardIndex, module, NAIBRD_CD_STATUS_FAULT_RES_LATCHED, &faultRaw);
naibrd_CD_GetAutoBurnCount(cardIndex, module, channel, &autoBurnCount);

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 — CD Basic Ops (every operation, interactively) · CD Manual and Auto Burn (the manual-vs-auto burn workflow with a live status-monitoring loop) — and Using NAI SSK 2.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 operation, see Features and Try it above.

Measurement & burn hardware: six (CD1) independent, isolated chip-detect channels with a repeatable resistance measurement (±5% FS, 0–100 kΩ), each with a SEPIC-regulated fuzz-burn circuit delivering 0.25–2.30 J (±10%) independent of input-voltage fluctuations, fed from a MIL-STD-704-tolerant +28 V input. A discharge is inhibited when the measured resistance is above the burn-suppression threshold (~2 kΩ) — if there’s no low-resistance bridge, there’s nothing to burn.

Built-In Test comes in three forms, logically OR’d into the BIT status registers (coverage is module-wide, for circuitry common to all channels):

• Power-On BIT (PBIT) — runs automatically at power-up; check naibrd_CD_CheckPowerOnBITComplete before trusting the latched BIT status.
• Initiated BIT (IBIT) — a user-commanded charge/discharge test on the BIT channel.
• Background / Continuous BIT (CBIT) — runs in the background (intervals on the order of ~150 s to minimize impact), charging and discharging the capacitor bank to an on-board load and checking the discharge profile; tune its sensitivity with the BIT error threshold.

The module also exposes Module Common Registers (bare-metal/FPGA revisions and compile times, unique serial number, and temperature/voltage/current monitoring) — see the “Module Common Registers Module Manual” referenced from the CD1 Manual.

Statuses you can monitor programmatically:

Status	What it tells you	Where
Fault resistance	Channel resistance at/below the fault threshold	GetChanMappedStatus(Raw) with NAIBRD_CD_STATUS_FAULT_RES_REALTIME / _LATCHED
Warning resistance	Channel resistance below the warning threshold	…_WARN_RES_REALTIME / _LATCHED
Open resistance	Channel resistance above the open threshold (open wire / no sensor)	…_OPEN_RES_REALTIME / _LATCHED
BIT	Module-wide built-in-test result	…_STATUS_BIT_LATCHED; naibrd_CD_CheckPowerOnBITComplete for PBIT
Auto-burn count	Burn attempts since arming (and “auto-burn complete” when max reached)	naibrd_CD_GetAutoBurnCount

Real-time status reflects the present condition; latched status holds an event until you clear it (write-1-to-clear). Enable a channel’s status reporting with naibrd_CD_SetChanStatusEnable, and clear the BIT logic/counter with naibrd_CD_ClearModuleBITLogic.

Common pitfalls

• Burn is suppressed above 2 kΩ. No burn fires — in any mode — while the measured resistance is above the 2 kΩ threshold. If a burn “won’t fire,” confirm the channel resistance is actually low enough; if it’s high, there’s nothing to burn.
• Channel not enabled. A disabled channel won’t trigger burns or report status. Enable the channels (naibrd_CD_SetEnabledChannels) before expecting readings or burns. Re-enabling a channel resets its burn counter to 0.
• Energy not set. A burn needs an energy setting (0.25–2.30 J). If burns seem ineffective, raise the energy toward the value your sensor/wire needs (~0.6 J for a 0.003” wire is typical).
• Auto-burn won’t trigger. Auto-burn fires off the fault threshold — if resistance never reaches the fault threshold (or stays above 2 kΩ), it won’t burn. Verify the thresholds and that auto-burn is armed (naibrd_CD_InitiateAutoBurnChannels).
• Threshold ordering. Keep 0 < Fault < Warn < Open. Mis-ordered thresholds make Warning/Fault/Open status meaningless.
• No open detection without a monitor resistor. Open-circuit detection relies on a parallel monitor resistor and an Open threshold set above it; without it, a disconnected sensor can look like a clean (high-resistance) channel.
• Reading BIT before PBIT completes. Check naibrd_CD_CheckPowerOnBITComplete before trusting the latched BIT status at power-up.
• Status reporting disabled. If a channel never asserts status/interrupts, confirm naibrd_CD_SetChanStatusEnable is on for that channel.

Related resources

• CD1 Manual — the module manual (registers and the full naibrd_CD_* API)
• CD Basic Ops — exercise every CD operation interactively (SSK 2.x)
• CD Manual and Auto Burn — the manual-vs-auto fuzz-burn workflow with status monitoring (SSK 2.x)
• 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_CD_* calls run against
• Running Applications from the Target — load and launch a built sample on the board