Mil Std 1553 Bus Loading

MIL-STD-1553 Bus Loading (avionics/data-bus/mil-std-1553-bus-loading)

Use when the task is MIL-STD-1553 bus loading at the schedule level: how many wire words each message type puts on the 1 Mbps bus, how long the message occupies the bus, and whether the whole minor-frame schedule fits an 80 percent loading guideline. The model converts each message into command and status overhead plus data words, charges a fixed 24 microsecond word slot per wire word, and returns the utilization and the headroom to the budget. It pairs with avionics/data-bus/mil-std-1553, which owns the 20-bit word encode/decode and format classification side, and with avionics/data-bus/arinc429-bus-loading, the per-channel sibling loading model.

Domain quick reference

• Wire words per message (command and status overhead plus data words): BC-to-RT: 1 command + data_words + 1 status = data_words + 2; RT-to-BC: 1 command + 1 status + data_words = data_words + 2; RT-to-RT: 2 commands + 1 status + data_words = data_words + 3. A message carries 1 to 32 data words.
• Word slot: WORD_TIME_US = 20.0 us (20 bit times per word at the 1 Mbps data rate) plus WORD_GAP_US = 4.0 us inter-word gap gives WORD_SLOT_US = 24.0 us per wire word.
• Message time: message_time_us = wire_words * WORD_SLOT_US, exact.
• Schedule total: sum of the per-message times over the minor-frame schedule.
• Utilization: utilization_pct = total_us / frame_us * 100, with the default minor frame FRAME_US_DEFAULT = 5000.0 us (5 ms).
• Loading guideline: LOAD_BUDGET_FRACTION = 0.80, budget_us = 0.80 * frame_us; verdict is FITS when total_us <= budget_us, OVER otherwise.
• Headroom: headroom_us = budget_us - total_us; headroom_pct = (budget_us - total_us) / frame_us * 100, negative when OVER.
• Identity examples: BCRT 16 data words = 18 wire words; RTRT 8 data words = 11 wire words; each wire word costs exactly 24 us.

Workflow

1. Lay out the minor-frame message schedule as (kind, data_words) pairs, with kind one of BCRT, RTBC, RTRT and data_words in 1..32.
2. Convert each message to wire words with wire_words: the function adds the command and status overhead (2 for BCRT and RTBC, 3 for RTRT).
3. Convert each message to bus time with message_time_us (wire words times the 24 us slot), or read the per-message times from the schedule summary.
4. Sum the schedule against the minor frame with schedule_utilization: it returns total_us, utilization_fraction, utilization_pct, budget_us, headroom_us, headroom_pct and the verdict. Pass frame_us only when the minor frame is not the default 5000 us.
5. Read the headroom percent directly from the summary, or call schedule_headroom for the scalar (0.80 * frame - total) / frame * 100.
6. Confirm the deterministic checks with the contract test scripts/test_mil_std_1553_bus_loading.py.

Worked example

Reference schedule on a 5 ms minor frame (5000 us, budget 4000 us):

• BC-to-RT 16 data words: 18 wire words = 432.0 us.
• RT-to-BC 32 data words: 34 wire words = 816.0 us.
• RT-to-RT 8 data words: 11 wire words = 264.0 us.
• BC-to-RT 4 data words: 6 wire words = 144.0 us.

Module outputs for this schedule:

• total_us = 1656.0 us (432 + 816 + 264 + 144).
• utilization_pct = 33.12 percent (1656 / 5000 * 100), verdict FITS.
• budget_us = 4000.0 us, headroom_us = 2344.0 us.
• headroom_pct = 46.88 percent ((4000 - 1656) / 5000 * 100).
• A schedule four times larger totals 6624 us = 132.48 percent, verdict OVER, headroom_pct = -52.48 percent.
• Hand check: RT-to-RT 32 data words = 35 wire words = 840.0 us.

Verification

• Confirm wire_words("BCRT", 16) returns 18 and message_time_us("BCRT",
  16. returns 432.0 us exactly.
• Confirm schedule_utilization on the reference schedule returns total_us 1656.0, utilization_pct 33.12, verdict FITS, headroom_pct 46.88.
• Confirm the four-times schedule returns 132.48 percent with verdict OVER and a negative headroom_pct.
• Confirm dict keys are exactly total_us, utilization_fraction, utilization_pct, budget_us, headroom_us, headroom_pct, verdict.
• Confirm unknown kinds, data_words outside 1..32, frame_us <= 0 and an empty schedule all raise ValueError.
• Confirm utilization_pct equals total_us / frame_us * 100 and message time equals wire_words * 24 exactly (identity checks).
• Run the contract test offline: python3 scripts/test_mil_std_1553_bus_loading.py (35 tests, deterministic).

Related leaves

• avionics/data-bus/mil-std-1553: the protocol leaf for the 20-bit word encode/decode and format classification side of the same bus.
• avionics/data-bus/arinc429-bus-loading: the per-channel loading model for the other avionics data bus standard.
• avionics/data-bus/arinc664-afdx: switched network utilization for the Ethernet-based avionics backbone.

Pitfalls

• Counting data words only: the wire-word count must include the command and status overhead (data_words + 2 for BCRT and RTBC, data_words + 3 for RTRT), so a 16-data-word BC-to-RT message costs 18 wire words and 432 us, not 16 words and 384 us.
• Charging only the word time: the bus is occupied for the word time plus the inter-word gap, 24 us per wire word; quoting 20 us per word understates a 1656 us schedule by 276 us.
• Forgetting the RT-to-RT second command: an RT-to-RT message carries two command words, one more wire word than the BC-to-RT or RT-to-BC forms at equal data words (35 against 34 at 32 data words).
• Treating the 80 percent budget as a frame fill target: the guideline leaves 20 percent of the frame as margin, so a 33.12 percent load on a 5 ms frame has 46.88 percent headroom to the 4000 us budget, not 66.88 percent to the frame end.
• Judging FITS against 100 percent: a schedule can exceed 100 percent of the frame (132.48 percent in the four-times case) and still be judged only OVER; report the percent utilization and the headroom, not just the verdict.
• Reading headroom as microseconds: headroom_pct is expressed as a percentage of the frame length, so it does not equal headroom_us divided by 100 on a 5 ms frame.

Behavior contract (gate 3)

Run the deterministic contract test (stdlib unittest, offline):

python3 scripts/test_mil_std_1553_bus_loading.py

The test covers the wire-word contract for every message kind at the worked-example data-word counts (BCRT 16 = 18, RTBC 32 = 34, RTRT 8 = 11, BCRT 4 = 6, RTRT 32 = 35), the 1..32 data-word bounds, message times (432, 816, 264, 144 us) within 1e-9, the time identity wire_words * 24, the reference schedule summary (total 1656 us, 33.12 percent, FITS, 46.88 percent headroom, budget 4000 us) within 1e-4, the four-times OVER case (132.48 percent, negative headroom), exact dict keys, determinism, custom frame scaling, the exact-budget FITS boundary, and ValueError rejection of unknown kinds, out-of-range data words, non-positive frames and empty schedules.

Compliance

• Standards referenced, not reproduced: MIL-STD-1553B is the protocol framing standard cited here in reference-only mode; the loading model above is standard bus-scheduling methodology, summary-only per standards-map.yaml.
• compliance: STANDARDS-REF, gated: false.