DEV Community

Cover image for The Best Communication System Might Not Need a Transmitter
Sina Rezaei
Sina Rezaei

Posted on AI-assisted

The Best Communication System Might Not Need a Transmitter

We usually think of communication systems as active devices.

A transmitter generates a signal, a receiver picks it up, and some kind of processing happens on either side. That's how Wi-Fi, satellite links, Bluetooth, and spacecraft telemetry generally work.

But there's another interesting approach: what if a device doesn't generate its own signal at all?

Back in 1969, Apollo 11 left something on the Moon that demonstrates a different kind of engineering. It has no battery, no processor, no radio transmitter, and no software.

Yet scientists are still using it for measurements.

A device with no power supply

Apollo 11 carried a Laser Ranging Retroreflector (LRRR), a passive optical instrument placed on the lunar surface.

The Apollo 11 array contains 100 fused-silica corner-cube reflectors mounted on a 46 cm aluminum panel. Each cube is designed to return incoming light toward its source.

The interesting part isn't just the mirror design. It's what the system doesn't need.

There is no onboard power supply, electronic controller, or active transmitter. Scientists on Earth fire short laser pulses toward the Moon, and the reflector sends a portion of that light back.

The ground station measures the round-trip travel time and calculates the distance.

That's a completely different engineering approach from building a device that actively communicates with another system.

How does it actually work?

The key component is the corner-cube retroreflector.

A conventional flat mirror reflects light according to the angle of incidence. A corner cube uses three mutually perpendicular reflecting surfaces. This arrangement sends incoming light back approximately toward its original direction.

Here's the basic process:

flowchart TD
    A["Earth Observatory"] --> B["Laser Pulse"]
    B --> C["Moon: Corner-Cube Array"]
    C --> D["Reflected Light"]
    D --> E["Earth Telescope"]
    E --> F["Time-of-Flight Measurement"]
    F --> G["Earth-Moon Distance"]

The distance calculation is straightforward:

[
d = \frac{c \times t}{2}
]

Where:

  • (d) = distance to the reflector
  • (c) = speed of light
  • (t) = measured round-trip time

For an average Earth-Moon distance of approximately 384,400 km, the round trip takes about 2.56 seconds.

That sounds simple until you consider the actual engineering challenge: sending a narrow laser beam across hundreds of thousands of kilometers and detecting the extremely small amount of light that returns.

This isn't ordinary optical communication. It's precision measurement.

Three different ways to avoid conventional active communication

The interesting comparison isn't simply powered versus unpowered. These systems solve different problems.

System How it works Independent power Main purpose
Active RF Generates and transmits its own signal Yes, typically Communication
Passive RFID Harvests reader energy and modulates reflected RF No internal battery Identification and data exchange
Lunar Retroreflector Returns incoming laser light No Precision ranging

Consider passive UHF RFID.

A reader transmits a continuous RF signal. The tag captures some of that energy through its antenna, powers its chip, and changes its antenna impedance to modulate the reflected signal.

The reader detects those changes and decodes the tag's response.

This technique is called backscatter communication.

It's particularly useful in environments where maintaining thousands of battery-powered devices would be expensive.

But there's an important distinction: RFID can encode information in its response. The lunar reflector doesn't do that. It simply returns light, allowing the ground station to measure time and distance.

Same broad engineering idea of using an external signal, but very different capabilities.

The Mars connection: when a relay is better than a direct link

There's another interesting example in NASA's Mars missions.

A rover doesn't always need to send all its scientific data directly to Earth.

NASA's Mars Relay Network uses orbiters such as Mars Reconnaissance Orbiter and Mars Odyssey to receive data from surface vehicles and forward it toward Earth.

The architecture looks like this:

flowchart LR
    A["Mars Rover"] --> B["Mars Orbiter"]
    B --> C["Deep Space Network"]
    C --> D["Earth Mission Control"]

Why use an orbiter?

Because a rover has limited space, power, antenna capability, and communication opportunities. An orbiter can carry larger antennas and provide a more capable communication link.

This is a different solution to the same general engineering question:

Does every device need to handle the entire communication process itself?

Sometimes moving complexity to another part of the system produces a better overall architecture.

The trade-offs engineers actually need to consider

Passive designs aren't automatically better.

Removing a battery, processor, or transmitter can reduce hardware complexity, but it also limits what the device can do.

Engineering factor Active system Passive system
Signal generation Independent Depends on external source
Energy requirements Higher Lower at the device
Data processing Can be extensive Often limited
Operating range Depends on transmitter and receiver Strongly depends on external energy and detection
Maintenance May require power-system maintenance Fewer powered components
Functionality Flexible Task-specific

The lunar reflector also has its own problems.

NASA has investigated why some lunar retroreflector arrays return much weaker signals than expected. Dust accumulation, thermal effects, and degradation in optical performance are among the factors researchers have considered.

So even a design with no electronics can face serious environmental challenges.

Removing components doesn't remove physics.

A useful lesson for system designers

I think this is where the example becomes interesting beyond space exploration.

When designing an IoT device, sensor network, or distributed system, we often start by asking:

  • Which processor should we use?
  • How will the device transmit data?
  • What battery capacity do we need?
  • Which communication protocol should we implement?

But there's another question worth asking first:

Does this device actually need to generate, process, or transmit anything independently?

A passive RFID tag doesn't need its own battery. A lunar retroreflector doesn't need an onboard communication system. A Mars rover can use an orbiter to handle much of its data transmission.

These aren't interchangeable technologies, but they demonstrate an important design principle: assign responsibilities to the components that can perform them most efficiently.

Sometimes the best optimization isn't a faster processor or a better transmitter. It's removing a responsibility that the device never needed to handle in the first place.


What's your take?

When designing a distributed system, do you prefer giving every device independent capabilities, or moving some responsibilities to shared infrastructure when possible?

Top comments (0)