NAI Documentation

AR Module Guide

12 min read

AR Family Guide

Overview

The AR family is NAI’s line of ARINC avionics-bus communication modules. Like the serial (SC) family, AR is about digital communication — but where SC carries freeform serial (RS-232/422/485) in whatever protocol you define, AR speaks rigid aviation industry standards with fixed 32-bit word formats, fixed speeds, and a fixed electrical layer.

This page is the starting point for any AR module. Use it to understand the family, pick the member for the ARINC standard you need, wire it to an avionics device, and confirm you can talk to the module with a loopback. It’s aimed at engineers interfacing an NAI system to an avionics data bus — receiving, transmitting, or simulating ARINC traffic.

In a real system, ARINC 429 is the data backbone of commercial and transport aircraft avionics — it’s how air data computers, GPS/INS, VOR/DME/ILS nav radios, the autopilot, the flight management system, and EFIS displays exchange parameters like airspeed, altitude, and heading. An AR module lets your system receive labeled words from those avionics boxes, transmit words to drive other equipment, or simulate a device for test. (NAI offers related avionics-bus families as well: M1553 for MIL-STD-1553 and the CAN modules for CANbus.)

For a short visual introduction to the ARINC family, watch this overview:

AR modules at a glance

AR1 and AR2 support different ARINC standards, so choose the module that matches the standard your equipment uses:

ModuleChannelsStandardDirectionSpeedManual
AR18ARINC 429 / 575Each channel programmable transmit or receive12.5 / 100 kbpsAR1 Manual
AR22ARINC 568 (CH1) / 579 (CH2)Receive-primary, transmit/simulate; programmable11 kbpsAR2 Manual

Choosing a member:

  • Standard ARINC 429 (or 575) — the common case for modern avionics data buses — AR1 (8 channels, each freely set to transmit or receive, selectable 12.5/100 kbps).
  • Legacy navigation interfaces — ARINC 568 (DME) and 579 (VOR) — AR2 (CH1 = 568, CH2 = 579, point-to-point, 11 kbps).

Unless you specifically need the older 568/579 nav interfaces, AR1 is the appropriate choice.

Combination modules that include ARINC 429:

ModuleCombinesManual
CM2Discrete I/O + ARINC 429CM2 Manual
CM5MIL-STD-1553 + ARINC 429CM5 Manual

Physical setup

ARINC is a two-wire differential bus (a twisted, balanced signal pair per channel), and each channel is one-directional — you set it to transmit or receive. The exact pins are per-module, so get them from that module’s manual; the pattern is the same:

  1. Identify the module’s slot number on your NAI motherboard or system.
  2. Bring the channel signal pairs out through the breakout board, where the slot’s pins appear as generic IO# numbers.
  3. Map IO# pins to each channel’s differential pair — by the pinout in the module’s manual or the module’s overlay card.
  4. Wire the channel’s pair to the avionics device.

A few things hold for the family:

  • A channel transmits or receives — not both. On AR1 you program each channel’s direction (naibrd_AR_SetTxEnable / naibrd_AR_SetRxEnable). A transmit channel drives the bus; a receive channel listens.
  • One transmitter, many receivers (ARINC 429). A single 429 transmit pair can feed up to ~20 receivers — it’s point-to-multipoint. (AR2’s 568/579 is point-to-point only.)
  • Both ends must agree on speed. Set the channel to the bus speed — 12.5 or 100 kbps for 429 (naibrd_AR_SetBaudRate). A mismatch yields no usable data.
  • Data is 32-bit labeled words. Each ARINC word carries an 8-bit label (what the data is) plus data, sign/status, and parity. Receivers can filter by SDI/label so only the relevant words are processed.

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

  • Receive from an avionics box (e.g. an air data computer). Set an AR1 channel to receive at the bus speed, and wire the box’s ARINC 429 output pair to that channel’s differential inputs. The module captures 32-bit labeled words into its receive FIFO; enable label filtering if you only want specific parameters.
  • Transmit / simulate to drive equipment. Set an AR1 channel to transmit, wire its differential output pair to the target’s ARINC input, load 32-bit words (label + data) into the transmit FIFO, and trigger the send.

Software

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

Where to find what you need:

  • Which functions/registers to call — the specific module’s manual (e.g. AR1 Manual) documents every naibrd_AR_* register (baud, parity, transmit/receive enable, FIFO, label filtering, status).
  • 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 AR1 module: pull the naibrd_AR_* calls from the AR1 Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch an ARINC sample on the target per Running Applications from the Target.

Confirm communication

An ARINC channel is one-directional, so the self-test is an external loopback across two channels: make one channel a transmitter, another a receiver, jumper their pairs together, send a word, and read it back.

Wire it: jumper channel 0’s transmit pair to channel 1’s receive pair (both set to the same speed).

Run it:

/* Channel 0 = transmitter */
naibrd_AR_SetBaudRate(cardIndex, module, 0, NAIBRD_AR_SPEED_LOW);
naibrd_AR_SetParityBitUsage(cardIndex, module, 0, NAIBRD_AR_PAR_ODD);
naibrd_AR_SetTransmitSendMode(cardIndex, module, 0, NAIBRD_AR_TX_SENDMODE_IMMED);
naibrd_AR_SetTxEnable(cardIndex, module, 0, NAI_TRUE);
 
/* Channel 1 = receiver */
naibrd_AR_SetBaudRate(cardIndex, module, 1, NAIBRD_AR_SPEED_LOW);
naibrd_AR_SetParityBitUsage(cardIndex, module, 1, NAIBRD_AR_PAR_ODD);
naibrd_AR_SetReceiveMode(cardIndex, module, 1, NAIBRD_AR_RX_FIFO_MODE);
naibrd_AR_SetRxEnable(cardIndex, module, 1, NAI_TRUE);
 
/* Send one 32-bit word on ch0, then read it back on ch1 */
naibrd_AR_LoadTxFifo(cardIndex, module, 0, 0, &word, &nSent);
naibrd_AR_SetTxSendTrigger(cardIndex, module, 0);
 
naibrd_AR_GetRxFifoCnt(cardIndex, module, 1, &count);
naibrd_AR_ReadRxFifo(cardIndex, module, 1, NAI_FALSE, count,
                     RecvStatusWd, RecvData, RecvTimeStamp, &nRecv);

If the word you sent on channel 0 comes back on channel 1, your board connection, SSK, and the module are all confirmed. (Both channels must use the same speed and parity.) The ar429_xmit and ar429_recv samples do exactly this transmit/receive pair.

Features

Each ARINC channel is one-directional — set up to transmit or receive — and driven through the naibrd_AR_* API. The blocks below group the calls by what a channel is doing, with the SSK 1.x and 2.x signatures side by side. (The 1.x → 2.x rename is visible throughout: SetDataRate→SetBaudRate, SetParityAsData→SetParityBitUsage, SetTxSendMode→SetTransmitSendMode, SetRxMode→SetReceiveMode, TransmitBuffer→LoadTxFifo, ReadFifo→ReadRxFifo, GetStatus→GetChanMappedStatus, and nai_ar_* enum types → naibrd_ar_*.)

Transmit a channel

What it does: configure a channel as a transmitter — set the data rate, parity, and send mode — then enable it, load 32-bit words into the Tx FIFO, and trigger the send.

Applies to: AR1 (ARINC 429); each channel is independently set to transmit or receive.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_AR_SetDataRate(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_datarate_t datarate);
nai_status_t naibrd_AR_SetParityAsData(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_parity_t parityasdata);
nai_status_t naibrd_AR_SetTxSendMode(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_tx_mode_t txsendmode);
nai_status_t naibrd_AR_SetTxEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_AR_TransmitBuffer(int32_t cardIndex, int32_t module, int32_t channel, int32_t msglen, uint32_t* msgbuf, int32_t* outmsglen);
nai_status_t naibrd_AR_SetTxSendTrigger(int32_t cardIndex, int32_t module, int32_t channel);
/* SSK 2.x */
nai_status_t naibrd_AR_SetBaudRate(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_datarate_t dataRate);
nai_status_t naibrd_AR_SetParityBitUsage(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_parity_t parityUsage);
nai_status_t naibrd_AR_SetTransmitSendMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_tx_mode_t txSendMode);
nai_status_t naibrd_AR_SetTxEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_AR_LoadTxFifo(int32_t cardIndex, int32_t module, int32_t channel, int32_t txCount, const uint32_t* p_buffer, int32_t* p_outtxCount);
nai_status_t naibrd_AR_SetTxSendTrigger(int32_t cardIndex, int32_t module, int32_t channel);

Exercise it: ARINC 429 Transmit · ESP2 “AR” tab.

Receive a channel

What it does: configure a channel as a receiver — set the data rate and receive (FIFO) mode — enable it, then poll the FIFO and read the captured 32-bit words. Optionally filter by SDI/label and time-stamp each word.

Applies to: AR1 (ARINC 429); AR2 channels are receive-primary (568/579).

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_AR_SetDataRate(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_datarate_t datarate);
nai_status_t naibrd_AR_SetRxMode(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_rx_mode_t rxmode);
nai_status_t naibrd_AR_SetRxEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_AR_GetRxBufferCnt(int32_t cardIndex, int32_t module, int32_t channel, int32_t* outcount);
nai_status_t naibrd_AR_ReadFifo(int32_t cardIndex, int32_t module, int32_t channel, bool_t timeStampEnabled, uint32_t msglen, uint32_t* outstatus, uint32_t* outdata, uint32_t* outtimestamp, int32_t* outnummsgs);
nai_status_t naibrd_AR_SetRxTimeStampEn(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
/* SSK 2.x */
nai_status_t naibrd_AR_SetBaudRate(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_datarate_t dataRate);
nai_status_t naibrd_AR_SetReceiveMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_rx_mode_t rxMode);
nai_status_t naibrd_AR_SetRxEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_AR_GetRxFifoCnt(int32_t cardIndex, int32_t module, int32_t channel, int32_t* p_outcount);
nai_status_t naibrd_AR_ReadRxFifo(int32_t cardIndex, int32_t module, int32_t channel, bool_t timeStampEnabled, int32_t rxCount, uint32_t* p_outstatus, uint32_t* p_outdata, uint32_t* p_outtimeStamp, int32_t* p_outrxCount);
nai_status_t naibrd_AR_SetLabelEnable(int32_t cardIndex, int32_t module, int32_t channel, uint32_t SDILabel, bool_t enable);
nai_status_t naibrd_AR_SetRxTimeStampEn(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

Exercise it: ARINC 429 Receive · ARINC 429 Receive Summary · ESP2 “AR” tab.

Status, BIT & monitoring

What it does: read per-channel and per-word status, run Built-In Test, and tune error handling (store-on-error) for diagnostics.

Applies to: all AR modules.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_AR_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_status_type_t type, nai_ar_status_t* outstatusword);
nai_status_t naibrd_AR_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_status_t statusword);
nai_status_t naibrd_AR_InitiateBIT(int32_t cardIndex, int32_t module, int32_t channel, bool_t waitForResult);
nai_status_t naibrd_AR_CheckBITComplete(int32_t cardIndex, int32_t module, int32_t channel, bool_t* p_outbitComplete);
nai_status_t naibrd_AR_SetRxStoreErrorDisable(int32_t cardIndex, int32_t module, int32_t channel, nai_ar_store_on_error_disable_t storedisable);
/* SSK 2.x */
nai_status_t naibrd_AR_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_chan_mapped_status_type_t statusType, nai_status_bit_t* p_outstatusBit);
nai_status_t naibrd_AR_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_ar_chan_mapped_status_type_t statusType);
nai_status_t naibrd_AR_InitiateBIT(int32_t cardIndex, int32_t module, int32_t channel, bool_t waitForResult);
nai_status_t naibrd_AR_CheckBITComplete(int32_t cardIndex, int32_t module, int32_t channel, bool_t* p_outbitComplete);
nai_status_t naibrd_AR_SetRxStoreOnErrorEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);

Exercise it: ARINC 429 Receive Summary · ARINC 429 Interrupt.

Try it out

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_AR_* call takes. When you write your own program, you do the same — see Opening a Software Handle to Your Board.

Transmitting a channel — set speed and parity, choose a send mode, enable transmit, load the FIFO, and trigger:

/* SSK 1.x */
naibrd_AR_SetDataRate(cardIndex, module, channel, AR_SPEED_LOW);
naibrd_AR_SetParityAsData(cardIndex, module, channel, AR_PAR_ODD);
naibrd_AR_SetTxSendMode(cardIndex, module, channel, AR_TX_SENDMODE_IMMED);
naibrd_AR_SetTxEnable(cardIndex, module, channel, NAI_TRUE);
naibrd_AR_TransmitBuffer(cardIndex, module, channel, nWords, SendData, &nSent);
naibrd_AR_SetTxSendTrigger(cardIndex, module, channel);
/* SSK 2.x */
naibrd_AR_SetBaudRate(cardIndex, module, channel, NAIBRD_AR_SPEED_LOW);
naibrd_AR_SetParityBitUsage(cardIndex, module, channel, NAIBRD_AR_PAR_ODD);
naibrd_AR_SetTransmitSendMode(cardIndex, module, channel, NAIBRD_AR_TX_SENDMODE_IMMED);
naibrd_AR_SetTxEnable(cardIndex, module, channel, NAI_TRUE);
naibrd_AR_LoadTxFifo(cardIndex, module, channel, nWords, SendData, &nSent);
naibrd_AR_SetTxSendTrigger(cardIndex, module, channel);

Receiving a channel — set speed, put it in FIFO receive mode, enable receive, then poll the FIFO and read the words:

/* SSK 1.x */
naibrd_AR_SetDataRate(cardIndex, module, channel, AR_SPEED_LOW);
naibrd_AR_SetRxMode(cardIndex, module, channel, AR_RX_FIFO_MODE);
naibrd_AR_SetRxEnable(cardIndex, module, channel, NAI_TRUE);
 
naibrd_AR_GetRxBufferCnt(cardIndex, module, channel, &count);
naibrd_AR_ReadFifo(cardIndex, module, channel, NAI_FALSE, count,
                   RecvStatusWd, RecvData, RecvTimeStamp, &nRecv);
/* SSK 2.x */
naibrd_AR_SetBaudRate(cardIndex, module, channel, NAIBRD_AR_SPEED_LOW);
naibrd_AR_SetReceiveMode(cardIndex, module, channel, NAIBRD_AR_RX_FIFO_MODE);
naibrd_AR_SetRxEnable(cardIndex, module, channel, NAI_TRUE);
 
naibrd_AR_GetRxFifoCnt(cardIndex, module, channel, &count);
naibrd_AR_ReadRxFifo(cardIndex, module, channel, NAI_FALSE, count,
                     RecvStatusWd, RecvData, RecvTimeStamp, &nRecv);

AR1 also supports scheduled transmits (a repeating message schedule) and asynchronous injection, and receive label filtering and time-stamping — see the manual and the interrupt sample.

Run it: ARINC 429 Transmit (SSK 2.x) · ARINC 429 Receive (SSK 2.x) · ARINC 429 Interrupt (SSK 2.x); AR2’s 568/579 samples are ARINC 568 Receive and ARINC 579 Receive; SSK 1.x equivalents include AR_Transmit, AR_Receive, and AR2_Receive. For the full set and how to build/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 AR hardware provides and what you can monitor — for how to drive transmit and receive (with the 1.x/2.x APIs), see Features above.

Hardware capabilities. Each AR1 channel backs those operations with a 255-message transmit FIFO (immediate, triggered, or scheduled send, plus asynchronous message injection), a 255-message receive FIFO/mailbox with SDI/label filtering, per-word receive time-stamping, optional store-on-error capture, and channel-event interrupts.

Statuses you can monitor programmatically. AR’s status is communication-oriented (FIFO state and per-word receive status), rather than the BIT/overcurrent style of DT/AD:

StatusWhat it tells youExample constant / call
RX data availableA channel has received words waiting in its FIFONAIBRD_AR_STATUS_SUMMARY_RX_AVAIL_LATCHED, naibrd_AR_GetRxFifoCnt
TX FIFO stateTransmit FIFO almost-empty / empty / full — for pacing your transmitsNAIBRD_AR_EVENT_STATUS_GENERAL_TX_FIFO_ALM_EMPTY / _TX_FIFO_EMPTY / _TX_FIFO_FULL_LATCHED
Per-word receive statusEach received word carries a status word (parity/error flags, label match)the RecvStatusWd returned by naibrd_AR_ReadRxFifo

Read channel/event status with naibrd_AR_GetChanMappedStatus (2.x) / naibrd_AR_GetStatus (1.x). The ARINC 429 Receive Summary sample is built around reading receive status across channels. ESP2’s status panel shows AR status interactively if you’d rather watch it in a GUI first.

Common pitfalls

  • Channel direction doesn’t match its role. A channel set to transmit won’t receive, and vice versa. Set it explicitly with naibrd_AR_SetTxEnable / naibrd_AR_SetRxEnable (and naibrd_AR_SetReceiveMode for RX).
  • Speed mismatch. Both ends of the bus must run the same rate — 12.5 vs 100 kbps on 429. A mismatch gives no data or garbage. Set it with naibrd_AR_SetBaudRate.
  • Parity mismatch. ARINC 429 uses odd parity by default (NAIBRD_AR_PAR_ODD); make sure both ends agree.
  • No messages received with label filtering enabled. SDI/label filtering drops words that don’t match the configured labels — if expected messages are missing, check or disable the filter.
  • Trying to transmit and receive on one channel/bus. ARINC 429 is one-way per channel — use separate channels for each direction (that’s why the loopback self-test needs two).
  • Treating AR2 like a 429 module. AR2 is ARINC 568/579 (legacy nav, 11 kbps, point-to-point), not 429 — CH1 is 568, CH2 is 579. Use AR1 for ARINC 429.
NAI Docs Assistant
Was this document helpful?