ARINC 717 (DFDR)¶

Overview¶

ARINC 717 defines the Digital Flight Data Recorder (DFDR) interface a continuous bit-stream protocol used to record flight parameters onto crash-survivable storage. Unlike ARINC 429's discrete word bus, ARINC 717 delivers a synchronous serial stream of 12-bit words organized into frames and subframes, enabling deterministic parameter recovery even from damaged media.

Key Facts

Word size: 12 bits
Word rates: 64, 128, 256, 512, or 1024 words per second (wps)
Encoding: Harvard Bi-Phase (self-clocking)
Frame structure: 4 subframes per frame (1 second at all word rates)
Superframe: 16 frames = 64 seconds (for slow-sampled parameters)
Usage: Flight Data Recorders (FDR), Quick Access Recorders (QAR)

Frame Structure¶

Subframe Organization¶

Each frame lasts 1 second regardless of word rate. The frame is divided into 4 equal subframes:

Frame (1 second)
┌─────────────────────────────────────────────────────────────────────┐
│  Subframe 1   │  Subframe 2   │  Subframe 3   │  Subframe 4       │
│  (250 ms)     │  (250 ms)     │  (250 ms)     │  (250 ms)         │
│               │               │               │                   │
│ SYNC₁ + data  │ SYNC₂ + data  │ SYNC₃ + data  │ SYNC₄ + data     │
└─────────────────────────────────────────────────────────────────────┘

At 256 wps, each subframe contains 64 words (1 sync word + 63 data words).

Word Rate Allocation¶

Word Rate	Words/Subframe	Words/Frame	Bit Rate	Clock Freq
64 wps	16	64	768 bps	768 Hz
128 wps	32	128	1,536 bps	1,536 Hz
256 wps	64	256	3,072 bps	3,072 Hz
512 wps	128	512	6,144 bps	6,144 Hz
1024 wps	256	1024	12,288 bps	12,288 Hz

Synchronization Patterns¶

12-Bit Sync Words¶

Each subframe begins with a unique sync word. The four sync patterns share a bitwise complement relationship that enables robust synchronization:

Subframe 1: 0x247  (001 001 000 111)
Subframe 2: 0xDB8  (110 110 111 000)  ← complement of 0x247
Subframe 3: 0x36C  (011 011 011 100)
Subframe 4: 0xC93  (100 100 100 011)  ← complement of 0x36C

Complement Relationship

The sync pattern pairs are bitwise complements:

0x247 ⊕ 0xFFF = 0xDB8
0x36C ⊕ 0xFFF = 0xC93

This property enables frame synchronization even when the decoder enters mid-stream finding any single sync word reveals which subframe you're in, and the complement relationship provides confirmation.

Synchronization State Machine¶

stateDiagram-v2
    [*] --> SEARCH
    SEARCH --> VERIFY: Sync word found
    VERIFY --> SYNC: Next expected sync confirmed
    VERIFY --> SEARCH: Unexpected pattern
    SYNC --> SYNC: Continuous valid syncs
    SYNC --> FLYWHEEL: Sync missed (1 frame)
    FLYWHEEL --> SYNC: Sync recovered
    FLYWHEEL --> SEARCH: 3 consecutive misses

State	Behavior
SEARCH	Bit-by-bit scanning for any valid sync pattern
VERIFY	Confirm sync by checking next expected subframe sync
SYNC	Locked; data extraction active
FLYWHEEL	Tolerates brief sync loss (tape dropout, noise)

Harvard Bi-Phase Encoding¶

ARINC 717 uses Harvard Bi-Phase (also called differential Manchester / Bi-Phase Mark) encoding:

Data:    1     0     1     1     0     0     1
        ┌──┐  ┌────┐┌──┐  ┌──┐  ┌────┐┌────┐┌──┐
Signal: │  └──┘    ││  └──┘  └──┘    ││    ││  └──
        ────────────────────────────────────────────
Clock:  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑  ↑

Properties:

Transition at every bit boundary (clock recovery)
Additional mid-bit transition for logic 1
No mid-bit transition for logic 0
Self-clocking: no separate clock line needed
DC-balanced: suitable for transformer coupling and tape recording

Why Harvard Bi-Phase?

FDR tape media is AC-coupled it cannot distinguish sustained high/low levels. Harvard Bi-Phase guarantees transitions at every bit boundary, enabling reliable clock recovery even at very low bit rates (768 Hz for 64 wps).

Superframe Concept¶

16 Frames = 64 Seconds¶

Parameters that change slowly (e.g., aircraft weight, fuel quantity) don't need per-frame sampling. The superframe concept allows parameters to be mapped to specific frame positions within a 16-frame cycle:

Superframe (64 seconds)
┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│ F0  │ F1  │ F2  │ F3  │ F4  │ F5  │ F6  │ F7  │...
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
  │                               │
  └── Slow param A (every 16s) ──┘

Parameter Sampling Rates¶

Rate	Update Period	Typical Parameters
1× per frame	1 second	Altitude, airspeed, heading
1× per 4 frames	4 seconds	Engine parameters, temperatures
1× per 16 frames	16 seconds	Fuel quantity, aircraft weight
1× per superframe	64 seconds	Configuration, discrete states

12-Bit Data Encoding¶

BNR (Binary Number Representation)¶

Signed or unsigned binary with defined range and resolution:

12-bit BNR:
┌────┬──────────────────────────────────┐
│Sign│         Magnitude (11 bits)       │
└────┴──────────────────────────────────┘
 B12   B11  B10  B9  B8  B7  B6  B5  B4  B3  B2  B1

Resolution = Full_Range / 2^11

Example: Altitude (0–131,072 ft)

12-bit unsigned BNR
Resolution: 131,072 / 2^12 = 32 ft/bit
35,000 ft → 35000 / 32 = 1094 → 0x446

BCD (Binary Coded Decimal)¶

Three BCD digits in 12 bits:

┌────────┬────────┬────────┐
│ Digit3 │ Digit2 │ Digit1 │
│ (4bit) │ (4bit) │ (4bit) │
└────────┴────────┴────────┘
 B12-B9   B8-B5    B4-B1

Discrete Parameters¶

Individual bits representing switch states or discrete conditions:

Bit 12: Gear handle position (0=UP, 1=DN)
Bit 11: Flap selector detent 3
Bit 10: Flap selector detent 2
...
Bit 1:  Nose wheel steering engaged

Parameter Mapping¶

Data Frame Layout (256 wps example)¶

Subframe 1, Word Position:
┌──────┬──────┬──────┬──────┬──────┬──────┬─────┐
│Sync  │ W2   │ W3   │ W4   │ W5   │ W6   │ ... │
│0x247 │Alt(H)│Alt(L)│Aspd  │Hdg(H)│Hdg(L)│     │
└──────┴──────┴──────┴──────┴──────┴──────┴─────┘

12-Bit Word Pairs

Parameters requiring more than 12 bits of resolution use word pairs consecutive words where the first contains the MSBs and the second the LSBs. Altitude commonly uses 2 words for 24-bit resolution (0.125 ft/bit).

API Reference¶

Core Types¶

#include "arinc717.h"

typedef enum {
    A717_RATE_64   = 64,
    A717_RATE_128  = 128,
    A717_RATE_256  = 256,
    A717_RATE_512  = 512,
    A717_RATE_1024 = 1024
} a717_word_rate_t;

typedef enum {
    A717_SYNC_SEARCH,
    A717_SYNC_VERIFY,
    A717_SYNC_LOCKED,
    A717_SYNC_FLYWHEEL
} a717_sync_state_t;

typedef struct {
    uint16_t words[4096];       // Max frame buffer (1024 wps × 4 subframes)
    a717_word_rate_t rate;
    uint8_t  current_subframe;  // 0-3
    uint16_t current_word;      // position within subframe
    uint16_t frame_counter;     // 0-15 (superframe position)
    a717_sync_state_t sync_state;
} a717_frame_t;

Encoder/Decoder Functions¶

// Initialize frame context
void a717_init(a717_frame_t *frame, a717_word_rate_t rate);

// Encode: write parameter into frame at (subframe, word_position)
void a717_encode_word(a717_frame_t *frame, uint8_t subframe,
                      uint16_t word_pos, uint16_t value);

// Decode: read parameter from frame at (subframe, word_position)
uint16_t a717_decode_word(const a717_frame_t *frame, uint8_t subframe,
                          uint16_t word_pos);

// Insert sync words into frame
void a717_insert_syncs(a717_frame_t *frame);

// Validate sync at subframe start; returns true if valid
bool a717_verify_sync(const a717_frame_t *frame, uint8_t subframe);

Harvard Bi-Phase Functions¶

// Encode frame words to bi-phase bit stream
// Returns number of bits written
size_t a717_biphase_encode(const uint16_t *words, size_t word_count,
                           uint8_t *bitstream, size_t max_bits);

// Decode bi-phase bit stream to 12-bit words
// Returns number of words decoded
size_t a717_biphase_decode(const uint8_t *bitstream, size_t bit_count,
                           uint16_t *words, size_t max_words);

Synchronization¶

// Feed raw bi-phase decoded bits; returns sync state
a717_sync_state_t a717_sync_feed(a717_frame_t *frame,
                                  const uint16_t *words,
                                  size_t count);

// Get current subframe index (valid only when LOCKED)
uint8_t a717_get_subframe(const a717_frame_t *frame);

// Get superframe counter (0-15)
uint8_t a717_get_superframe_pos(const a717_frame_t *frame);

BNR/BCD Helpers¶

// Encode floating-point value to 12-bit BNR
uint16_t a717_bnr_encode(double value, double range, bool is_signed);

// Decode 12-bit BNR to floating-point
double a717_bnr_decode(uint16_t raw, double range, bool is_signed);

// Encode integer to 12-bit BCD (3 digits)
uint16_t a717_bcd_encode(uint16_t value);

// Decode 12-bit BCD to integer
uint16_t a717_bcd_decode(uint16_t raw);

Build & Run¶

make -C src/aerospace/arinc717
./build/arinc717_demo

Output:

=== ARINC 717 DFDR Protocol Demo ===
Word rate: 256 wps | Frame: 1s | Subframes: 4 | Superframe: 16 frames

--- Frame Structure ---
Subframe 1 sync: 0x247 ✓
Subframe 2 sync: 0xDB8 ✓ (complement of SF1)
Subframe 3 sync: 0x36C ✓
Subframe 4 sync: 0xC93 ✓ (complement of SF3)

--- Harvard Bi-Phase Encoding ---
Raw word:  0x247 (001001000111)
Encoded:   01-01-10-01-10-10-01-01-01-10-10-10 (24 bits)
Decoded:   0x247 ✓

--- Parameter Encoding (BNR) ---
Altitude 35000 ft → 0x446 (resolution: 32 ft/bit)
Airspeed 250 kts  → 0x1F4 (resolution: 0.5 kts/bit)
Heading  270.0°   → 0x780 (resolution: 0.176°/bit)

--- Synchronization State Machine ---
Feeding unsynchronized stream...
State: SEARCH → found 0x247 → VERIFY
State: VERIFY → confirmed 0xDB8 → LOCKED
Processing frame data...
State: LOCKED (stable for 10 frames)

=== RESULTS: 28 passed, 0 failed ===
=== ALL TESTS PASSED ===

Comparison: ARINC 717 vs ARINC 429¶

Feature	ARINC 717	ARINC 429
Purpose	Flight data recording	Avionics data bus
Word size	12 bits	32 bits
Topology	Point-to-point stream	Single TX, ≤20 RX
Encoding	Harvard Bi-Phase	Bipolar RZ
Addressing	Word position in frame	Label field (octal)
Data rate	768–12,288 bps	12.5/100 kbps
Self-clocking	Yes (bi-phase)	Yes (RZ transitions)
Error detection	Sync word validation	Odd parity (32nd bit)

References¶

ARINC Specification 717-13 (2011)
ARINC Characteristic 573 (predecessor)
EUROCAE ED-112A: MOPS for Crash Protected Airborne Recorder Systems