In 2015, NASA put out a job posting looking for a software engineer with a specific set of skills. The person had to be an expert in Fortran and Assembly, two programming languages from the 40’s and 50’s that most young graduates don’t know. The job was to join the very small team of people working on the Voyager space probes.

Incredibly, both Voyagers still run on their original 50 year old computers, which have just 70 kilobytes of memory, the same as a really low quality image. It might not sound like much, but it was enough to navigate both space probes through our solar system and make incredible discoveries along the way.

Voyager’s telemetry problem

Unsurprisingly, things do go wrong with Voyager’s computers. Just last year, Voyager 1 started sending back garbled telemetry data about its orientation in space. After months of investigation, engineers discovered that it was trying to send its telemetry via a faulty backup computer that had been turned off years ago. This mixed up the data, making it unreadable to the engineers. 

On top of that, the thrusters in charge of keeping Voyager pointing in the right direction were starting to show signs of fatigue. Every time the thrusters are used, tiny pieces of hydrazine fuel get stuck in the pipes. This has built up over time, causing blockages in the system. Voyager is already on its backup thrusters, and so if these failed, it would be the end for Voyager. 

At a distance of 15 billion miles, there is no way of clearing the tubes. But in order to slow down the buildup and to fix the telemetry problem, the small team in charge of Voyager began writing a software update that could be sent across our universe to fix it. But this isn’t the first time Voyager has been updated.

Voyager updated after leaving Neptune

As Voyager made its way through the Solar System, the light from the Sun became dimmer and dimmer. At Neptune, the light was 900 times dimmer than it was at Earth. So in order to take pictures, engineers had to reprogram the camera to take longer exposures. 

Once it left Neptune, NASA began shutting down things like the camera and various scientific instruments to save power. But with just 70 kilobytes of memory onboard its computer, having lines of code for dead instruments was a waste of space. And so, the engineers completely rewrote Voyager’s code and performed a software update to make sure it continued to live for the foreseeable future.

Voyager’s computer systems

There are 3 main computers onboard Voyager: the main computer controls all of the major instruments, maintains its health and temperature – and also controls the other two computers. This computer has just 4 kilobytes of memory and can perform about 25,000 tasks a second. To put this into perspective, the newest iPhones can do at least 10 trillion tasks per second. 

The 2nd computer is in charge of Voyager’s orientation – so it looks for predetermined reference points and fires the thrusters to keep Voyager’s antenna pointing towards Earth. The 3rd computer is in charge of storing and handling all of the scientific data and images taken by Voyager’s instruments. But how does NASA update such old hardware from 15 billion miles away?

Each computer has its own plated-wire memory, which stores Voyager’s code in its most basic form, 1’s and 0’s.

Plated-wire memory

This memory consists of a physical grid of wires and thin metal plates. Each intersection point can be thought of as a single bit of memory – and it can store either a 1 or a 0. By passing a current through one of the plates and a specific wire, it would create a magnetic field. If the magnetic field is in this direction, it’s considered a 0. If it goes in the opposite direction, it’s a 1.

By passing a current through in the opposite direction, it would change the direction of the magnetic field and flip the bit to a 0. By doing this for every point, you could save these 1’s and 0’s into the memory. This design was a great choice at the time because it meant that even if the power went out, the 1’s and 0’s would still be saved to the memory. It also meant that each bit could be updated.

What language is Voyager coded in?

With just 70 kilobytes of total memory onboard Voyager, the engineers have to be extremely efficient with their code. Voyager doesn’t have an operating system – and any kind of programming language would take up too much space. All the code onboard Voyager is just 1’s and 0’s, which all the hardware and instruments can understand.

Along with this basic machine code, Voyager has its own pseudo code. This is basically a series of shortcut commands that can be triggered to allow Voyager to carry out repetitive tasks without taking up too much memory. An interpreter onboard the main computer reads through the 1’s and 0’s. Once it comes across a predetermined code, it initiates the pseudo code to carry out a command. This saves lots of memory and allows many tasks to be automated without writing out long lines of code.

But the problem is that humans can’t code in just 1’s and 0’s. And so a more advanced language is needed to actually write the code for Voyager. On Earth, Voyager’s software was originally written in assembly language with a little bit of Fortran.

Sending the update to Voyager

Assembly is a very simple language that can be understood by humans but is much closer to the basic 1’s and 0’s of machine language. Once the code is complete, it gets compiled into machine code which can be sent to Voyager using the deep space network.

These dishes are the only ones powerful enough to talk to Voyager. The data is sent to Voyager at a rate of 16 bits per second and it takes almost an entire day to actually reach Voyager. That means, it takes around 2 days for the engineers to actually know if their code was received by Voyager.

The computers onboard Voyager are interrupt driven, like most of today’s computers. This means that the software goes through its usual list of instructions until it gets interrupted. When an update is sent to Voyager, it carries an interrupt signal.

When Voyager receives this, it tells the main computer to stop what it’s doing and instead work on the update instructions. It then unloads the new code into the memory, flipping all the bits to their new position. The code is then read through to check that everything is correct and then the main computer kicks it into gear and returns to normal operations.

Over the years, Voyager has received a long list of updates and patches to fix and improve how it operates. In 1995, an update was written that would basically restart certain components if they failed. In 2014, some 20 years after the code was written, this code saved Voyager 1 when a piece of hardware malfunctioned. In 2010, a single bit in Voyager’s memory was flipped, changing a 0 to a 1.

This caused computers to lose sync with each other and commands started happening 2 and a half hours later than expected. A software update was sent up to flip the faulty bit back to its correct position. It’s amazing stories like these that have allowed these iconic space probes to survive almost 50 years in space. It’s incredible that the physical wires, transistors and hardware onboard Voyager’s computers are still operating as intended after all this time.

References