Voyager 1 erreichte im August 2012 den interstellaren Raum und ist das am weitesten entfernte von Menschen gemachte Objekt ((Hier findet ihr den aktuellen Missionsstatus von Voyager 1 – https://voyager.jpl.nasa.gov/mission/status/)). Voyager 1 wurde kurz nach seiner Schwestersonde Voyager 2 im Jahr 1977 gestartet und erforschte die jupianischen und saturnischen Systeme ((Hier verweise ich auf den ausführlichen Wikipediaartikel zum Thema Saturn und Jupiter – https://de.wikipedia.org/wiki/Saturn_(Planet) )), entdeckte neue Monde, aktive Vulkane und eine Fülle von Daten über das äußere Sonnensystem.
Die Voyager 1 und 2 wurden entwickelt, um die seltene Ausrichtung der Planeten zu nutzen, die nur einmal in 176 Jahren auftritt. Beide Raumsonden tragen eine Art Zeitkapsel namens Golden Record , ((Anbei eine Übersicht über die Golden Record – https://voyager.jpl.nasa.gov/golden-record/golden-record-cover/)) eine vergoldete 12-Zoll-Kupferscheibe mit Klängen und Bildern, die ausgewählt wurden, um die Geschichte unserer Welt für Außerirdische darzustellen.
Voyager Golden Record Cover Explanation https://commons.wikimedia.org/wiki/File:Voyager_Golden_Record_Cover_Explanation.svg
Ich gehe davon aus, dass die große Mehrheit der Menschen, die die Software für diese Missionen erstellt haben, jetzt im Ruhestand ist ((Die Raumfahrt-Rentner der Voyager-Mission. Sehr gute Zusammenfassung zum aktuellen Software Team der Voyager Missionen – https://www.swr.de/swr2/programm/sendungen/wissen/die-raumfahrt-rentner-der-voyager-mission/-/id=660374/did=15958530/nid=660374/10sk2n7/index.html)) ((Eine weitere kurze Erwähnung was genau für eine Programmiersprache genau genutzt wurde – https://www.popularmechanics.com/space/a17991/voyager-1-voyager-2-retiring-engineer/)), aber in den letzten 40 Jahren der fortschreitenden Entwicklung sind die Programiersprachen natürlich stark fortschrittlich. Einst hatte das Voyager Team über 200 Mitarbeiter, aktuell sind es noch 8 Mitarbeiter. ((Ein sehr guter Audio Beitrag zum Thema Voyager Team, hier als Zusammenfassung – https://www.swr.de/-/id=15958532/property=download/nid=660374/1s7qh3e/swr2-wissen-20150914.pdf))
Immerhin wurden die beiden Sonden noch mit Fortran, und Assembler programmiert. In den Raumsonden selber verrichten Uralt-Prozessoren von General Electric ihr Werk. Sie müssen dabei mit einem 64-Kilobyte-Speicher auskommen. ((Hier in diesem Interview auch nochmal erklärt warum es 64kb sind, und nicht weniger wie es einige behaupten – https://www.popularmechanics.com/space/a17991/voyager-1-voyager-2-retiring-engineer/))
Viking CCS memory.
https://history.nasa.gov/computers/p163b.jpg
The Flight Data System hardware
So startete sie 1977. Nach 35 Jahren erreichte Voyager den interstellaren Raum.
Aber warum stelle ich mir diese Fragen nun? Mich interessiert der Entwicklungsprozess hinter den Voyager Missionen. Und hier bin ich zwar selber noch mehr oder weniger in den Nasa Archiven am forschen, aber einiges konnte ich wenigstens schon beantworten.
Welche Prozessoren wurden genutzt?
Anscheinend verwendeten sie das von JPL speziell entwickelte und gebaute Computer Command System (CCS) des Viking-Landers. Sie haben geringfügige Modifikationen vorgenommen, um ein Flight Data System (FDS) und ein Attitude Articulation Control System (AACS) hinzuzufügen. Der CCS ist der Hauptcomputer und führt Befehle und Speicher aus, von denen er knapp 70 KB hat ((Hier in diesem Interview wird bestätigt das es 64 kilobyte sind – https://www.popularmechanics.com/space/a17991/voyager-1-voyager-2-retiring-engineer/)).
Der FDS übernimmt die Erfassung der wissenschaftlichen Daten und die Speicherung auf Magnetbändern (ich bin nicht sicher, ob das CCS auch Zugriff auf die Bänder hat, aber ich gehe davon aus!). Das AACS ist der Flugcomputer und steuert die Ausrichtung des Raumfahrzeugs (anscheinend erfüllt das CCS bei einigen dieser Dinge doppelte Aufgaben?).
Die AACS der Voyager-Sonden ((In diesem Artikel auführlich beschrieben – https://www.allaboutcircuits.com/news/voyager-mission-anniversary-computers-command-data-attitude-control/)) bestimmen die Ausrichtung und halten sie auf die Erde gerichtet. Die ursprüngliche Absicht der Designer war es, eine neue Technologie namens „HYSPACE“ (Hybrid Programmable Attitude Control Electronics) für das AACS zu verwenden. HYSPACE kombinierte analoge und digitale Elemente, verwendete Indexregisteradressierung und eine serielle 4-Byte-Architektur. Dies erlaubte die Verwendung des gleichen Codes für alle drei Achsen des AACS.
Different types of packaging used in the Viking computer system. Note the discrete components in the leftmost device. (JPL photo 360-276-AC)
Voyager verwendete den gleichen Computer wie der Viking Orbiter nur in einem seiner 3 computergestützten Subsysteme (Command and Control Subsystem). Das Attitude- und Articulation Control Subsystem hat eine erweiterte Version des CCS-Computers verwendet, der eine Einheit (die Hybrid-Puffer-Interface-Schaltung (HYBIC)) zwischen CPU und RAM eingefügt hat, die die Befehle abgefangen hat, um die indizierte Adressierungsfunktion (auf Kosten anderer Anweisungen) hinzuzufügen. und beschleunigte Anweisungen, die Leerlaufzyklen verwendeten. Der dritte Computer, der im Flight Data Subsystem verwendet wurde, war ein neues benutzerdefiniertes Design im CMOS mit 128 Registern, serieller Nibble-CPU und 8096 Wörtern mit 16-Bit-RAM. Es lieferte ungefähr 80.000 Anweisungen pro Sekunde.
Dazu dieses Zitat mit weiteren Informationen:
NASA reeled from massive budget cuts during the 1970s. A changed political climate ended the Apollo era of near „carte blanche.“ Hampered by expensive Shuttle contracts as well as other factors, NASA management reduced its plans for unmanned exploration of the solar system. As Voyager developed under the new conditions, cost savings became a key ingredient in all engineering evaluations. JPL thus conducted a „CCS/CCS Memory Subsystem Design Inheritance Review“ on January 17, 19749. Held a year after Greenberg’s proposal for standardizing the Viking computer, the Review resulted in the adoption of the Viking CCS as the Voyager CCS. The eventual hardware functional requirements document reads like a copy of the Viking document10. I/O interfaces with the new Flight Data System and Attitude Articulation and Control System computers are the major differences. Software such as the command decoder, certain fault processing routines, and others are fundamentally identical to Viking11. Here again, differences are related to the new computers. All command changes and memory loads for the other computers are routed through the CCS12. This required the addition of the routine MEMLOAD13. Another routine, AACSIN, was added to evaluate power codes sent from the Attitude Control computer as a „heartbeat“ to inform the CCS of its health14. The frequency of the heartbeat, roughly 30 times per minute, caused concern [176] that the CCS would be worn out processing it. Mission Operations estimated that the CCS would have to be active 3% to 4% of the time, whereas the Viking Orbiter computer had trouble if it was more than 0.2% active15. As it turns out, this worry was unwarranted. Part of the reason why the more complex Voyager spacecraft could be controlled by a computer with the same size memory as Viking is the ability to change software loads. In-flight reprogramming, begun when the programmable sequencers flew on Mariners, and brought to a state of high quality on Mariner X, was a nearly routine task by the time of Voyager’s launch in 1977. Both the CCS and Flight Data System computer have been reprogrammed extensively. No less than 18 loads were uplinked to Voyager l during its Jupiter encounter. During long-duration cruise, such as between Saturn and Uranus, new loads are spaced to every 3 months16. As pioneered on Mariner X, a disaster backup sequence was stored in the Voyager 2 CCS memory for the Uranus encounter, and later for the Neptune encounter. Required because of the loss of redundancy after the primary radio receiver developed an internal short, the backup sequence will execute minimum experiment sequences and transmit data to earth; it occupies 20% of the 4K memory17. CCS programmers are studying ways to use some bit positions in a failed Flight Data System memory to compensate for the shortened memory in their system. A readout register in the Flight Data System has a failed bit, giving the impression that the entire memory has a one stored in that position in each word. Remaining „good“ areas may be assigned to the use of the CCS18.
Hier noch Informationen zu den einzelnen zur genutzen Hardware:
In dieser Übersicht gibt es nun ein Blockdiagramm der Hardware des Viking Orbiter Command Computer Subsystems. Diese grundlegende Konfiguration mit zwei Computern wurde sowohl für Viking-Computer als auch für alle drei Voyager-Computersysteme verwendet.
Blockdiagramm für Viking und Voyager CCS. ((Blockdiagramm für Viking und Voyager – https://history.nasa.gov/computers/p158.htm))
Wie viele Codezeilen gibt es und in welcher Sprache ist der Source geschrieben?
Geschrieben wurde der Source Code der Voyager Missionen in Fortran und Assembler, in Teilen auch umgestellt auf C ((Hier wird explizit auch auf die Umstellung auf C hingewiesen – also neben Fortran und Assembler hat man eben auch auf C umgestellt – https://www.wired.com/2013/09/vintage-voyager-probes/)). ((Spezielle Informationen zur Entwicklung des Fortran Source Codes im Rahmen der Voyager Missionen mit Hinweis das erst Fortran 5 nutzte und dann auf Fortran 77 ((Hier noch einige Informationen zu Fortran 77 – https://de.wikipedia.org/wiki/Fortran)) ((Hier sind noch allgemeine Informationen zu finden zum Thema ob der Source Code von Voyager öffentlich ist – https://www.muckrock.com/foi/united-states-of-america-10/voyager-command-analysis-software-source-code-28641/))
„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.“
Hier anbei eine Übersicht der einzelnen Source Zeilen Pro Mission seit 1969.
- 1969 Mariner-6 (30)
- 1975 Viking (5K)
- 1977 Voyager (3K)
- 1989 Galileo (8K)
- 1990 Cassini (120K)
- 1997 Pathfinder (175K)
- 1999 DS1 (349K)
- 2003 SIRTF/Spitzer (554K)
- 2004 MER (555K)
- 2005 MRO (545K)
Laut dem folgenden Beitrag gibt es den Source Code für Apollo 11 und verschiedene andere NASA-Projekte, die offen (Open Source?) sind, aber der Source der Voyager Sonden scheint hier zu fehlen: https://voat.co/v/programming/comments/306663
Fortran zu Python
Interessant finde ich eben auch die Tatsache das es in Python eben einen Fortran Wrapper gibt ((Fortan to Python Wrapper – Hier in der Übersicht https://de.wikibooks.org/wiki/Fortran:_Fortran_und_Python)),((Hier noch weitere Informationen zum Fortran to Python Wrapper – https://sysbio.ioc.ee/projects/f2py2e/)), wird dieser oder ähnliche Lösungen im Voyager Team genutzt?
Wäre sicherlich eine Möglichkeit, auch den in die Jahre gekommen Source entsprechend noch anzupassen. Ob das Voyager Team aber immer nocht Fortran77 nutzt , oder C, oder eben Wrapper für beides, dass konnte ich bisher noch nicht ganz erkennen. Da sind die Informationen einfach noch zu schwammig. Aber ich bleibe an dem Thema dran.
Wie sahen die Entwicklungsprozesse hinter den Missionen aus? Sind diese noch aktiv?
Neueste Kommentare