# How the Telemetry System in the Apollo 11 Spacecraft Software Transmitted Data to Earth

> Discover the Apollo 11 telemetry system an interrupt-driven subsystem transmitting critical spacecraft data to Earth every 20 milliseconds using the DOWN-TELEMETRY PROGRAM.

- Repository: [Chris Garry/Apollo-11](https://github.com/chrislgarry/Apollo-11)
- Tags: deep-dive
- Published: 2026-03-04

---

**The telemetry system in the Apollo 11 spacecraft software is an interrupt-driven down-link subsystem that transmits selected on-board data to ground stations every 20 milliseconds via the DOWN-TELEMETRY PROGRAM.**

The Apollo 11 Command Module software, preserved in the `chrislgarry/Apollo-11` repository, contains a deterministic telemetry pipeline responsible for streaming critical flight data to Mission Control. This **telemetry system in the Apollo 11 spacecraft software** operates as a real-time down-link mechanism, packaging erasable memory contents and hardware channel states into formatted transmissions sent through dedicated spacecraft interfaces.

## The DODOWNTM Interrupt Handler

At the heart of the telemetry system lies the `DODOWNTM` interrupt handler in `Comanche055/DOWN-TELEMETRY_PROGRAM.agc`. This routine triggers every 20 milliseconds when the spacecraft’s telemetry converter generates a "down-telemetry end-pulse."

```assembly
DODOWNTM    TS      BANKRUPT
            EXTEND
            QXCH    QRUPT          # Save Q (interrupt flag)

            CA      BIT7           # Set word-order code = 1 (temporary)

            EXTEND
            WOR     CHAN13         # Force word-order = 0 for the new list

            TC      DNTMGOTO       # Jump to the appropriate phase

```

The handler saves the current interrupt state, initializes **word-order code** handling via `CHAN13`, and transfers control to the telemetry phase manager. This design ensures that data transmission resumes seamlessly even after system restarts by re-initializing the list pointer `DNTMGOTO` to the beginning of the current list.

## Down-Link List Processing

The telemetry system uses configurable **down-link lists** defined in `Comanche055/DOWNLINK_LISTS.agc` to determine which data addresses are transmitted. Each list consists of control words followed by address descriptors (`1DNADR`, `2DNADR`) and channel identifiers (`DNCHAN`).

The `FETCH2WD` routine retrieves data from erasable memory based on the current list pointer:

```assembly
FETCH2WD    CA      DNECADR        # Load current down-link address

            TS      EBANK          # Switch to the target erasable bank

            MASK    LOW8           # Isolate low-order address bits

            TS      L
            CA      DNADRDCR      # Decrement count & ECADR

            ADS     DNECADR
            EXTEND
            INDEX   L
            EBANK=  1400
            DCA     1400          # Fetch two data words

            EBANK=  DNTMBUFF
            TCF     DNTMEXIT      # Send them out

```

This bank-switching mechanism allows the telemetry program to access any location in the **erasable memory** space, fetching double-precision words for transmission.

## Writing to Telemetry Channels

Once data is fetched, the `DNTMEXIT` routine writes words to the hardware down-link channels. In `Comanche055/DOWN-TELEMETRY_PROGRAM.agc`, the system outputs to **channels 34 and 35** using the `WRITE` instruction:

```assembly
DNTMEXIT    EXTEND
            WRITE   DNTM1          # Word → Channel 34

            CA      L
            WRITE   DNTM2          # Word → Channel 35

            TCF     RESUME         # Return to caller

```

This pipeline transmits approximately 200 AGC words every 2 seconds (100 double-precision words), maintaining a constant data stream to ground stations throughout the mission.

## Word-Order Codes and Data Formatting

The system manages **word-order codes** through `CHAN13` to instruct ground decoders how to recombine double-precision words. These bit-fields, documented in `Luminary099/INPUT_OUTPUT_CHANNEL_BIT_DESCRIPTIONS.agc`, ensure that high-order and low-order portions of data words are correctly reassembled by Mission Control's receiving equipment.

## Ground-Initiated Memory Dumps

The telemetry system supports on-demand **erasable-memory dumps** via the `DNEDUMP` routine, triggered by uplink verb 74 (VB74). When ground control sends this command through `Comanche055/EXTENDED_VERBS.agc`, the software initiates a special dump mode:

```assembly
; In EXTENDED_VERBS.agc
TC  DNEDUMP    # VB74 – initialise down-telemetry program (dump)

```

Unlike the periodic telemetry stream, `DNEDUMP` transmits entire erasable banks following the same list-driven scheme but with expanded address ranges, allowing engineers to retrieve complete memory snapshots for debugging.

## Restart Protection and Flags

Telemetry operations are protected against system faults through initialization logic in `Comanche055/FRESH_START_AND_RESTART.agc`. On fresh start or restart, the system clears telemetry flags and resets the down-link list pointer, ensuring that transmission resumes from a known state rather than corrupting mid-stream data.

## Summary

- The **DOWN-TELEMETRY PROGRAM** operates as a 20-millisecond interrupt service routine triggered by `DODOWNTM`.
- Data selection occurs via configurable **down-link lists** that specify erasable memory addresses and hardware channels.
- Transmission occurs through **channels 34 and 35**, managed by the `WRITE` instruction in the `DNTMEXIT` routine.
- **Word-order codes** in `CHAN13` ensure proper reassembly of double-precision words at ground stations.
- Ground control can initiate full memory dumps using **VB74** (`DNEDUMP`) through the extended verbs interface.
- Restart protection in `FRESH_START_AND_RESTART.agc` ensures telemetry integrity after system resets.

## Frequently Asked Questions

### How often did the Apollo 11 telemetry system transmit data?

The system transmitted data every 20 milliseconds via the `DODOWNTM` interrupt, resulting in approximately 200 AGC words (100 double-precision words) being sent to ground stations every 2 seconds throughout the mission.

### What hardware channels did the telemetry system use?

According to `Comanche055/DOWN-TELEMETRY_PROGRAM.agc`, the system wrote data to **down-link channels 34 and 35** using the `WRITE` instruction, while **channel 13** managed word-order codes for data formatting.

### How was the telemetry system restarted after a system fault?

The `FRESH_START_AND_RESTART.agc` file contains logic that re-initializes the `DNTMGOTO` list pointer and clears telemetry flags on fresh start or restart, ensuring the **DOWN-TELEMETRY PROGRAM** resumes from the beginning of the current down-link list rather than continuing with corrupted state.

### What is the difference between regular telemetry and DNEDUMP?

Regular telemetry periodically transmits selected data words based on the active down-link list, while **DNEDUMP** (activated by uplink verb 74) initiates a complete dump of specified erasable memory banks, transmitting entire memory regions rather than curated telemetry samples.