The Software Behind Voyager 1

Author: Better Stack · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: The Software Behind Voyager 1 · Channel: Better Stack · 01:31 · Watch on YouTube

Topics: Data, databases and embeddings, Software engineering with AI, AI infrastructure and hardware, Robotics and autonomous systems

Summary

In November 2023, Voyager 1 began sending back repeating patterns of ones and zeros, even though it could still receive and carry out commands. The team used a command to make its data computer run different software, revealing a memory dump that helped them identify a failed chip and corrupted memory. Since the chip could not be replaced, they relocated the affected code in pieces and updated the program to call it from its new locations. They translated the changes into binary by hand, and the engineering data became readable again in April 2024.

Key points

Voyager 1’s data stopped making sense on November 14, 2023, while the spacecraft continued to receive and execute commands.
The fault was in the data computer that packages information and sends it back to Earth.
In March 2024, the team sent a command called a “poke” to make the computer run different parts of its software.
The changed signal turned out to be a dump of the computer’s memory, including code and variables.
A comparison with an earlier memory dump revealed a failed chip and about 3% corrupted memory.
The failed chip held one bit from each of 256 consecutive 16-bit words.
The team split the affected code into pieces and placed them in available gaps in memory.
They updated every program location that called the relocated code and translated the changes into binary by hand.
Readable engineering data returned two days after the code was sent on April 18, 2024.

Chapters

Start	Chapter	Summary
00:00	Voyager 1 stops sending readable data	Voyager 1 continues to carry out commands, but a fault in its data computer leaves the team unable to read what it sends back.
00:30	The team finds a failed chip	A memory dump lets the team identify a dead chip and about 3% corrupted memory.
01:01	Relocating the affected code	The team splits the code across available memory gaps and updates the program to use its new locations.
01:31	Readable data returns	After the team sends the hand-translated code, Voyager’s engineering data becomes readable again two days later.

Quotes

The spacecraft was still receiving commands and carrying them out — 00:00

a dump of the data computer’s entire memory, the code and all of its variables. — 00:30

A single chip had died — 00:30

translated every change into binary by hand. — 01:01

that data came back readable for the first time in 5 months. — 01:31

Concepts and entities

Voyager 1, Deep Space Network, NASA, assembler

Full transcript (original language)

00:00 On the 14th of November 2023, the data coming back from Voyager 1 stopped making sense at all. The spacecraft was still receiving commands and carrying them out, but what came back was just repeating patterns of ones and zeros. Fault was in the data computer that packs everything up and sends it home. The team could talk to Voyager, but they couldn’t read anything and send it back. In March 2024, they sent a command they call a poke, which nudged the data computer into running different parts of its software. 2 days later, the signal changed. An engineer at NASA’s Deep

00:30 Space Network, which manages the big dishes on Earth that talk to spacecrafts like Voyager, worked out that the new signal was a dump of the data computer’s entire memory, the code and all of its variables. The team compared it with a dump from before the problem started, and in April, they found the cause. A single chip had died, and about 3% of the computer’s memory was completely corrupted. So, how the hell do you fix a dead chip from 15 billion miles away? Well, you can’t replace it, so you just stop using it. The computer’s memory is split into slots called words, and each

01:01 word is 16 bits. The broken chip held one bit from each of the 256 words in a row. So, when it died, every one of those words had a bad bit, and the code stored in those words was a set of routines that got called from all over the rest of the program. The fix was to move the code somewhere else, but there wasn’t a single free gap big enough to hold all 256 words. So, the team split the code into pieces, put each piece in whatever small gap they could find, and then updated every place in the program that called it. They had to do this without an assembler. So, they

01:31 translated every change into binary by hand. On the 18th of April 2024, they sent up the code that packs the engineering data, the health readings from the spacecraft itself. 2 days later, that data came back readable for the first time in 5 months.