A patch was sent to Voyager 2 yesterday

1

Its distance being 18 light-hours (12 billion miles), we can hope today everything went well…

In this StackExchange discussion we learn the Voyagers have 3K lines of code onboard.

This Wired article says:

The spacecrafts’ original control and analysis software was written in Fortran 5 (later ported to Fortran 77). Some of the software is still in Fortran, though other pieces have now been ported to the somewhat more modern C.

So the sent patch was probably either written in C or directly in assembly language. It was tested for months before being sent to the outer solar system… Voyager 1, the farthest, will receive the patch later if everything goes well with VGER2.

I clearly remember having watched Uranus and Neptune flybys on TV in 1986 and 1989.

Updated 2024-04-24: the Voyager probes Fortran meme was finally debunked by A patch was sent to Voyager 2 yesterday - #53 by alexm

11 Likes
2

Too much Star Trek in you :smiley: !

1 Like
3

Blockquote
I clearly remember having watched Uranus and Neptune flybys on TV in 1986 and 1989.

Me too. How old we are.

2 Likes
4

Probably Fortran is still older !

2 Likes
5

If you find interesting facts about the Voyager’s computers and softwares, please share here!

Tomorrow, I should have access to my old dear books (not opened for so long…):

I will look for more information inside…

One true fact is that their hardware was high-tech as the software can be patched remotely… In the 80’s most 8-bit computers had their operating systems in a ROM (Read Only Memory). The bugs were frozen… (but they were finally rare, the size being not as monstrous as nowadays).

I have found that the communication rate with the Deep Space Network is now 16 bits/s for upload and 160 bits/s for download… :snail:

1 Like
6

The VGER in the movie was supposed to be a Voyager 6 launched in 1999:

Too bad it does not exist… Well, we have now New Horizons!

7

I’m guessing that part of the 3K lines of code prints out “Hello World”. :slightly_smiling_face: The question is how did NASA (actually a NASA contractor usually) accomplish this feat without OOP, templates, rigid TKR checking etc. Given the bloat in the language the same code would be 30K lines of code today to do the same thing. But hey, it would at least be “standard conforming”

6 Likes
9

“The Hello World Collection”

10

None of the Fortran examples listed there actually captures Fortran in its simplicity, as you could just have a 1-line program

      print *, 'Hello, World!'; end
2 Likes
11

These two probes were launched in 1977 (Voyager 2 sixteen days before Voyager 1), so I would have thought that the code might have been written originally in Ada. There was a significant push within US government agencies, in particular the department of defense, in the late 1970s and early 1980s to write all high-level code in Ada, and eventually to require all contractors to also write code only in Ada. That mandate never happened, but I don’t know why it didn’t. If it had, that would have been the end of fortran when it was at its peak of popularity, and perhaps the end of other popular computer languages of that era too. Of course, the code that was sent to the spacecraft was not fortran (or C or any other high level language); the spacecraft do not have compilers aboard.

1 Like
12

@RonShepard I’m afraid you’re a decade too early :slight_smile: … The development of ADA started in the mid-70s and the first official version and first full implementation were in 1983, long after the Voyager probes left the earth

2 Likes
13

Moreover technologies are often chosen early in a space program. Although in those days things were going faster than now: the late 60’s Grand Tour program was replaced by the Voyager program in 1972, using Mariner-derived spacecrafts. And five years latter, they were launched, which sounds incredible when you consider nowadays space missions… (not to mention they still work 46 years later…)

2 Likes
14

It took me a while to understand this simplicity :joy:.

1 Like
15

These are available from NASA Technical Reports Server

Project Gutenberg has:

3 Likes
16

At least the vector notation introduced in F90 results in less lines of code. And for code that runs on one system only and and is tested for months, a standard is indeed not very important.

17

Incredible! Thanks a lot!

There is a “THE BRAINS OF THE VOYAGER SPACECRAFT” frame in Voyage to Jupiter with some interesting information (page 28, or 40 in the PDF):

These capabilities resulted from three interconnected onboard computer systems: the AACS (attitude and articulation control subsystem); the FDS (flight data subsystem); and the CCS (computer command system).

The two identical (redundant) 4096-word memories within the CCS contained both fixed routines (about 2800 words) and a variable section (about 1290 words) for changing science sequencing functions.

18

There is a JPL repository:

But no code concerning Voyager.

Someone tried to obtain free access to the source code but was answered that the copyright is owned by Caltech:
https://www.reddit.com/r/nasa/comments/dz91xd/why_would_the_voyager_source_code_be_excluded_by/

19

Perhaps with much more manpower and longer developement time. Modern, safe languages (Fortran, Rust, Zig) allow you develop fast, deploy fast and run fast, even if you need to type in a few more words (keyboards are cheap).

20

The talk Uptime 15,364 days - The Computers of Voyager by Aaron Cummings sheds some light on the computational part of the probes (including redundancy of the computers and their quorum sensing).

2 Likes
21

Thanks for this interesting video.

The best information I have found yet on their computers is this blog:

Each computer system on the Voyager spacecraft was dual-redundant— there were two CCS’, two FDS’, and two AACS’.

The CCS (Computer Command System) was similar to the Viking one:

The Viking CCS had two of everything: power supplies, processors, buffers, inputs, and outputs. Each element of the CCS was cross strapped which allowed for “single fault tolerance” redundancy so that if one part of one CCS failed, it could make use of the remaining operational one in the other.

Those redundancies are one of the reasons of the longevity of the mission!

Interestingly, there was some kind of parallelism:

The CCS could also operate in three modes: individual (each CCS completes tasks independent of one another), parallel (both CCS work on a task together), or tandem (each CCS works on the same task independently). During near encounters with targets (Jupiter, Saturn, etc.), the CCS would be in tandem mode.

On an architectural level, the CCS processors contained an instruction interpreter, data path control, and registers (18-bit accumulator, 12-bit link register, 12-bit program counter, 4-bit condition code register) which operated in serial. Instructions were 18-bit words, with the most significant 12-bits containing addresses (4k of direct addressing), and the least significant 6-bits containing operation codes (64 instructions).

The FDS (Flight Data System) was using CMOS volatile memory, and for this reason was directly in line with the radioisotope generator, to avoid any loss.

If you can access, this 1980 conference paper is very interesting: https://doi.org/10.1243/PIME_PROC_1980_194_026_02

The processor is using interruptions.

The Voyagers have an 8-track tape recorder capable of storing 5e8 bits. At Jupiter the communication rate was 115200 bits/s, at Saturn 44800 bits/s. Now it is 160 bits/s (with a 70 m antenna, the signal being at -160 dBm), or a glorious 1.4 kbits/s if you use five antennas… Upload is at 16 bits/s (you don’t want an error when sending commands) and you need a 19 kW power…

Finally, maybe I should stop polluting the Fortran Discourse and sign up on that Retro Computing Discourse :grin::

5 Likes