Contents

What is "Luminary"?

AGC software family treeLuminary is the program which was run on the Apollo Guidance Computer installed in the Lunar Module (LM).  In order to be loaded into the AGC—actually, to be converted to the "core ropes" within the AGC—it was necessary to "assemble" Luminary's source code into binary machine language, using a computer program called YUL.  In the context of the Virtual AGC project, of course, the process is somewhat different:  Luminary source code is assembled by the yaYUL program, and then loaded into the yaAGC simulation.

The figure at left (click to enlarge) concisely depicts the relationships among the LM AGC software and the relationship with the CM's AGC software, while the table to the right (click to enlarge) depicts the various versions of the software, at least for Apollo 5-14, though it has unfortunately been roughed up somewhat by optical-character recognition processing and so its contents can't be fully trusted

Known Luminary Software Versions

Summary of the Luminary Versions Available Here at this Site

Highlighted Versions, in Gory Detail, Whether We Have Them or Not

Actually, there are a lot of Luminary program versions we don't have, and won't ever have.  Thus, the reason Luminary 99 is called 99 is because of the 98 versions preceding it, all of which have now vanished with the wind ... we presume.  The same goes for the documentation associated with the software, so we only have incomplete snapshots at various points in time, and in the table below I've made an effort to associate important version-specific documentation with the software version.  However, in case of Luminary, we have an additional very important resource that I haven't bothered to link in on a version by version basis, but which you can nevertheless consult.  I refer to the so-called LUMINARY Memos, a collection of 250+ internal Instrumentation Labs covering many aspects of the Luminary development process, including extensive descriptions of revision-to-revision changes.  Instead of trying to isolate which memos are specific to which of the many program revisions, I'll just recommend that you browse the memo collection yourself as you see fit.

Mission LM Number Mission
Type
LM Program Version Source Code
Mission-specific documentation
What We Know About It, in a Nutshell
N/A
N/A
N/A
Retread
44
As colorized, hyperlinked,  HTML

or

Reduced-size  scanned JPG
(43MB)

or

High-quality scanned JPEG 2000
(82MB)
N/A
As you've seen elsewhere on this site, there where two major versions of the AGC, the Block I and Block II models.  While there was never any Block I code for the Lunar Module, as far as I am aware anyway, there was certainly Block I code for the Command Module, and at some point a transition was made both from writing Block I code to writing Block II code ... but also from writing CM code to writing LM code, and Retread marks that transition point!  It's the veritable Missing Link of AGC code, which is particularly a propos since in fact the YUL development system employed for AGC development didn't sport a linker.  (Joke!  Feel free to ignore.)

In other words, Retread was when Block I code for the CM began to be adapted into Block II code for the LM.  Thus, like Aurora below, Retread was never intended to be mission code, and was never flown.  But it has the honor of being the "first" LM software.  It is, in fact, more than a year older than any other AGC software of any kind (Block I, Block II, CM, LM) available publicly at the present time, as far as I'm aware!

Indeed, if you look at the date on this software — I'll save you the trouble; it's July 9, 1965 — that's the same time (within a month or two) of when the first Block II AGCs were actually becoming available, and thus the only way to have run RETREAD at that time was probably in a digital simulation.  But of course, digital simulations in advance of actual hardware are never perfect, so there would be every possibility that RETREAD 44 may not be exactly compatible with Block II AGC hardware yet ... and it turns out that that's the case.  If, for example, you look at the self-check code, run by VERB 21 NOUN 27 ENTER 1 ENTER, not all of the CPU tests pass!  (There is a detailed write-up of this issue, if you're interested.)

At any rate, this particular program listing came to us from Don Eyles, via scanning at archive.org, financially-sponsored by Mike Higgins.
N/A
N/A
N/A
Aurora
12
As colorized, hyperlinked,  HTML

or

Reduced-size  scanned JPG
(100MB)

or

High-quality scanned JPEG 2000
(500MB)
N/A
Don Eyles, one of the AGC developers who you may know as the hero of Apollo 14, has contributed the hardcopy of this program from his personal collection.  We have had it scanned by archive.org, and Mike Stewart has generously financially-sponsored the scanning.  So, thanks Don and Mike!  As usual, we provide it here in the form of reduced-size (but therefore reduced-quality) images for easier access, but the original scans in their full quality are still available in our Virtual AGC collection at archive.org.

I suppose I should mention that if page 52 or 70 of the reduced-sized images look a little weird to you (oh, you conspiracy theorists with your Photoshopping theories!), I should mention that those were places where there was a paper-change on the printer, and I simply glued two partial pages together to make it look pretty.  You can look at the high-quality scans to see all of the pages in their original, un-Photoshopped glory, if you like.  There are also a couple of pages (622 and 623, I think), which are missing right now, but which archive.org should add within a couple of days of when I'm writing this.

Now before you go all elitist and thumb your nose at Aurora just because it never flew on an actual mission (even an unmanned one), let me tell you that from this project's standpoint it is quite a terrific find.  For one thing, it employs unique flavor of the AGC programming language; although it is a  Block 2 program for a Block 2 computer, the language version precedes its final form as used in the later software versions we have available, requiring changes to the assembler just to assemble it.  Technically, it was targeted at the "BLK2" software architecture rather than the "AGC" software architecture.

More significantly, it was the last version we know of to incorporate the full range of AGC testing software that had been created.  In actual mission software, most of this testing software was removed due to size constraints, and due to the fact (I presume) that most of the tests were more-appropriately done in the lab, as acceptance tests, rather than in space where nothing could be done about the failures anyway.  Why do we care about that?  Well, how do you think we test the AGC simulator anyway?  Pre-Aurora, our only choice was to roll our own tests, which the original AGC may not have even been able to pass for all we know.  But now that we have Aurora?  Well, we haven't yet converted it to source code, and couldn't assemble it yet without modifying the assembler to accept this flavor of assembly language anyway, so it's too early to say.  But once we do that, we hope that some lingering bugs in the simulator will be ferreted out, as well as to give us additional confidence in the simulator.  It's also a boon to developers of hardware AGC simulations, like Mike (who sponsored this), because they would like to validate their own simulators just as we would.

Finally, there's something of a mystery associated with Aurora 12.  The hardcopy we have of it is from November 10, 1966, and Aurora at the point should have had a version number in the 80's.  How could it be version 12?  Perhaps one day we'll know!
Apollo 5
LM-1

Sunburst
120
As colorized, hyperlinked,  HTML

or

Reduced-size  scanned JPG
(200MB)

or

High-quality scanned JPEG 2000
(500MB)
GSOP (R-527)
"Apollo Experience Report—Guidance and Control Systems: Lunar Module Mission Programer"

"LM-1 Trip Report at MSC - Flight Support and Debriefing"

"Results of Independent Flight Software Validation Test of the BURST116 Program for the LM-1 Mission"
Apollo 5 was an unmanned mission to test the LM, and as such it had a working AGC, though at certain points in the mission the ground controllers bypassed the AGC (which hadn't been planned for), using the AGS instead for some maneuvers.  The mission itself was not entirely successful.

The "Programer"—actually some sources spell it "programer" and some "programmer"—was a robotic gadget that was the stand-in for the crew.

Don Eyles provided the hardcopy for our the program-listing scan we present here.  It was scanned by archive.org, and was generously sponsored by Mike Stewart.  The original printout unfortunately has some problems in the vicinity of pp. 820-830, but we naturally correct those in our transcription.

The LM-1 Trip Report was provided by its author, AGC developer Jay Sampson, and provides a fascinating blow-by-blow description of what transpired during the actual mission, and a summary of the subsequent debriefing.
N/A
N/A
N/A
Super Job
N/A
As colorized, hyperlinked, HTML

or

Listing in Appendix D of Volume 2 of Raytheon document R68-4125
Raytheon R68-4125, volume 1, "Final Report: Auxiliary Memory for Apollo Guidance Computer"

Raytheon R68-4125, volume 2, "Final Report: Auxiliary Memory for Apollo Guidance Computer"

E-2254: "Auxiliary Memory System, Final Report on Phase I"
This program, Super Job, is a very unusual offering, in that it is AGC code not written by the MIT Instrumentation Lab, but rather by Raytheon.  Of course, sub-contractors from Raytheon, A.C. Electronics, and others, were used to help write the "regular" AGC programs as well, but this program is entirely written by Raytheon. 

Nor does it seem to have been assembled with the YUL or GAP assemblers used to assemble all of the other AGC code, but rather (as far as we can tell!) an in-house Raytheon assembler.  That in-house assembler is almost, but not quite, compatible with YUL/GAP: slightly different address formats were used, and the interpretation of certain operands is slightly different.  We support that with a special command-line switch (--raytheon) in yaYUL.

The way this program came about is that Raytheon was contracted to do a feasibility study for potentially expanding the AGC memory capacity by adding a magnetic-tape recorder.  If you have looked at our Gemini OBC (on-board computer) page, you'll know that the later Gemini missions did use a tape-memory unit to load different OBC software for different mission phases, and this is a similar idea.  The basic characteristics of the auxiliary memory were:
  • An Auxiliary Core Memory (ACM) consisting of memory cores:  Up to 16K 16-bit words, though only 8K×16 bits were used in the prototype units Raytheon actually built.
  • An Auxiliary Tape Memory (ATM) consisting of magnetic tape (108 bits capacity).
  • The ability to transfer data from the ATM to the ACM or vice-versa.
  • The ACM could be directly accessed in the address-space of the AGC as either "extended fixed memory" or "extended erasable memory" (see Table 2-2 in volume 1 of the Raytheon document hyperlinked to the left).

The auxiliary memory was never used in a mission, so you may suppose it was a completely-obscure feature, but there is actually some measure of legacy support for it, albeit very trivial, in every LM code version from Sunburst onward.  The way its effect is seen is that the AGC's so-called "superbit"— the flag in the memory-bank register that selects memory banks 40-43 vs banks 30-33 — actually consists of 3 bits even though single bit is needed.  The extra two superbits would have been used to select the various auxiliary-memory functions mentioned above.

The rationale for the auxiliary memory was that as "feature creep" (or perhaps "feature explosion") occurred during AGC development, more and more memory was required, surpassing the physical resources of the AGC itself.  Many "Tindallgrams" cover this, and indeed, very significant AGC features were developed in software and then simply discarded due to memory constraints.  For example, code was developed for the LM for something called a Lunar Optical Rendezvous System (LORS) that could potentially have been used in place of the Rendezvous Radar (RR).  However, the code for LORS was larger (much larger) than the code for the RR, thus causing it to be eliminated, so the only place it exists today is as a vague reference in a Tindallgram.  I wish we could see the code for LORS, but we cannot.  Perhaps if Raytheon's auxiliary tape memory for the AGC had eventually been adopted, we might be able to do just that!  But the tape memory was not adopted, so we cannot. 

Actually, the story I've been told (by MSC's Clark Neily) is that there was an intense dispute (which he labeled The Rendezvous Wars) between the optical camp (led by Max Faget) and the radar camp.  You can read Clark's extended comments about it in our document library.  The radar camp won for Apollo, but lost for the shuttle.  Such is life!

At any rate, Super Job is a test program for this tape-drive system.  While we provide the transcribed source code for SuperJob, it's probably not too useful to run it in the AGC simulator as of yet; probably the tape drive itself will have to be simulated as well, perhaps with a new program that might be named yaTape.  Or not; we'll have to wait and see.  It's also worth noting that the scanned program listing is rather wimpy in places, and has no niceties such as memory-bank checksums to give us confidence that the transcription of the source code is correct ... but we hope (and think) it probably is.

And finally, as you may have realized, there is actually no logical reason for including Super Job here on the Luminary page.  There's nothing in the documentation suggesting that it would be installed in the LM vs the CM.  Rather, it's just a generic concept that might apply to either spacecraft, or to both of them.  But it has to go somewhere, so here it stays!
Apollo 9
LM-3
D
Sundance
306

GSOP (R-557)
Flight Plan
Here is some info from James Kernan, one of the LGC developers, in response to my question about correct versioning of Sundance:

Sundance 306 is correct.  I was the "rope mother" for Sundance-Apollo 9.  ...  Sundance was not only the Apollo 9 LM flight program, it was also the development bed for the Lunar orbit and landing software.  At some point we created a version and called it Luminary.  I think the last few revisions of Sundance were devoted to disabling crew access to the Lunar orbit and landing software that was present in the build.

Jim also tells me that a copy of Sundance 306 may still "be in the building".  I'm not certain which building he's talking about, but it's nevertheless interesting news that a copy of the program does exist somewhere.
Apollo 10
LM-4
F
Luminary 1
069/2
As colorized, hyperlinked,  HTML

or

Reduced-size  scanned JPG
(200MB)

or

High-quality scanned JPEG 2000
(730MB)
GSOP (R-557)

LUMINARY Memo #75

The version we have here is from Don Eyle's private collection, as scanned by archive.org, and financially sponsored by our Onno Hommes.

Actually, though, it may not be quite the version actually flown on Apollo 10.  As it says right at the top of every page, it is REVISION 069 OF AGC PROGRAM LUMINARY BY NASA 2021112-011, whereas it is known that the version flown on Apollo 10 was Luminary 69 Rev. 2, 2021112-031, which was released five months later.  Such last-minute changes were often the result of ephemeris upddates or other time-sensitive data that had to be specific to the launch window, but we don't know this for sure at the moment.

Regardless, this is the closest thing to Apollo 10 mission software we have, or are likely to find, so beggars can't be choosers!
N/A
N/A
G
Luminary 1A
099


One of the original AGC programmers, Allan Klumpp, kept a copy of Luminary 99, since donated to klabs.org, having been told that it was the version that flew on Apollo 11.  Unfortunately, that turns out not to have been the case, but it's awfully close!

We know that the program identifies itself as "REVISION 099 OF AGC PROGRAM LUMINARY BY NASA 2021112-051" in the page headings of the printouts, so from the chart at the top of this page, it's the revision immediately preceding the flown version.  I hope some day to have it scanned, though with each passing year that seems an increasingly distant dream.

While we don't presently have access to Allan's program listing, a comparison of memory-bank checksums ("bugger words") has been made between the MIT Museum and Klumpp listings (thanks to Paul Fjeld and Allan Klumpp), and it has been found that these two listings have a small difference in memory bank 5.  As it happens, memory bank 5 is where ephemeris data resides, and we happen to know that that's one of the things that changed between Luminary 99 and Luminary 99 Rev 1.
Apollo 11
LM-5
G
Luminary 1A
099/1
As colorized, hyperlinked,  HTML

As scanned page images (very big!)

Page 1472

Page 1473
Erasable pad loads

Excerpted LM Systems Handbook

The 1201/1202 alarms

The Apollo 11 Adventure

Operational Data Book
Crew Debriefing
Flight Plan

"Exegesis of the 1201
and 1202 Alarms Which
Occurred During the
Mission G Lunar
Landing"


Digital simulations of the landing:
This is the AGC software version that we accept as having been flown in the Apollo 11 Lunar Module.

Page images have been taken from a hardcopy from the Charles Stark Draper Historical Collection, MIT Museum, and then converted to source code by a team of volunteers.

Honor Roll

Organizational honors

Massachusetts Institute of Technology / MIT Museum
Building N51, 265 Massachusetts Avenue
Cambridge, MA  02139
web.mit.edu/museum/


Individual honors
  • Deborah Douglas, the Museum's Curator of Science and Technology, who conceived the idea of making this material available to us, and without whom we had literally no chance of obtaining it.
  • Paul Fjeld, for digitizing the hardcopy.
  • (In alphabetical order) Fabrizio Bernardini, Hartmuth Gutshe, Onno Hommes, Jim Lawton, and Sergio Navarro, for converting the page images to source code.
  • Steve Case and Dawn Masuoka for helping in proofing the executable binary.
  • ... and those whose names I do not know at the Charles Stark Draper Laboratory and NASA who allowed us to do this.

Below, you can see a video made by Niklas Beug, in which this Luminary 99 AGC software is used to make a simulated Apollo 11 lunar landing, using the Orbiter spaceflight simulator, with the NASSP 7.0 Apollo-mission add-on and our own AGC CPU simulator.  (A higher-resolution version is probably available if you go directly to YouTube.)


The MIT Museum copy is dated 14 July, 1969, which seems odd at first glance, since it would be far too late to actually have been included in the Apollo 11 mission.  AGC developer Hugh Blair-Smith speculates that this is the date of the printing rather than of the program build, and that seems plausible.   At any rate, the printout identifies itself as "REVISION 001 OF AGC PROGRAM LMY99 BY NASA 2021112-061", which according to the chart at the very top of this web-page tells you that it is indeed the version that was flown in the mission ... but keep reading, because there's more to this story than meets the eye!

AGC developer Don Eyles also has a copy of Luminary 99, though oddly named AP11ROPE BY EYLES rather than LMY99 BY NASA, and it was printed in 1970 for some reason.  We will scan it in the near future.  We do happen to know that all of the memory-bank checksums are the same as the MIT Museum copy, so it is probably identical throughout ... though that's not guaranteed yet.  At any rate, the MIT Museum copy is missing portions of pp. 1472-1473, and Don has kindly sent us some snapshots of those pages from his copy, which we do present here.

Regarding the "digital simulations" mentioned to the right, these are simulations performed during the Apollo era, not simulations we have performed as part of the Virtual AGC project.  They are very complete, containing not only pad loads, but also position/velocity data, notations of what the astronaut is supposed to input on the DSKY, what the DSKY is displaying on a moment-to-moment basis, occasional memory dumps, and so on.   There are two such surviving simulations for Apollo 11, both from Don Eyles's personal collection.  We have had them scanned, with Matthew Fite financially sponsoring the 1968 version and Fabrizio Bernardini financially sponsoring the 1971 version.  (Thanks Matthew and Fabrizio!)  The two simulations are somewhat different; i.e., these are not merely two different scans of the same thing.  Unfortunately, the printout for the 1971 simulation is quite low-contrast, and its full-color scans quite hard to read, so I've provided a highly-processed, high-contrast B&W version as well.

But why, you wonder, was there a digital simulation of Apollo 11 in 1971, a couple of years after Apollo 11 landed on the moon?  Shouldn't the simulations only have been useful before the landing?  Well, Don Eyles had this simulation performed for his own purposes and (after nearly 50 years!) is no longer sure quite what that purpose was.  Now, he worked on several off-the-main branch AGC programs, such as ZERLINA (coming soon!), intended to explore improved methods for performing the landing; my theory is that this simulation provided baseline data against which to measure such improvements, and Don admits that this is a plausible theory.

Speaking of ZERLINA, if you examine the full-color scans for the digital simulation found at archive.org, you may notice that the label on the binder (removed in the B&W PDF I've posted here at this site) identifies the 1971 simulation as "DIANA Rev. 12".  It is not DIANA, however: the binder containing the simulation's printout had formerly contained a copy of DIANA, we believe, and Don simply reused it for this printout without relabeling it.  DIANA was another off-the-main-branch program, like ZERLINA, which was developed by Peter Adler and Don Eyles in order to explore an improved time-sharing technique that would avoid the 1201 and 1202 program alarms experienced in the Apollo 11 landing.  The approach wasn't adopted, though, and copies of DIANA no longer exist as far as we know.  (At any rate, neither Don nor Peter has a copy.)
N/A
N/A
G
Luminary 1A
099/2
As colorized, hyperlinked HTML

Here's where Apollo 11's software story gets complicated.

James Kernan, another of the original AGC developers, has sent us some confusing facts.  I'll let Jim tell it in his own words:

I was an employee at Draper Lab, and was in charge of the Lunar Module LGC computer programming group and also in charge of Assembly Control for the flight software during the Apollo 9-12 software development period.  The latter responsibility included reviewing all proposed alterations to the flight software and the YUL assembler inputs.

I can explain the confusion over the Luminary version that flew on Apollo 11.  We were aiming for Luminary Revision 99 as the Apollo 11 Lunar Module flight software.  There was a tradition (or rule) that the flight software version should have no revision, so we renamed Luminary Revision 099 as Lum99 Revision 0.  At the last minute, Dan Lickly, our chief engineer, appeared with ephemerides updates and it took two tries to get it right.  The result was that we created Lum99 Revision 1 and Lum99 Revision 2.  We made a no-change version of the later and named it Lum99R2 Revision 0.

The tapes and ropes were made from that.   That is my recollection.  Unfortunately, I did not have the foresight to keep a printout of the flight version.


And some years later, he retells it as:
The evening of the release for Apollo 11, John Sutherland and I were in the assembly control room about to make the final assembly of Luminary.  For reasons unsupportable by reason, I had decided that the Luminary revision for Apollo 11 would be less than 100 and lo and behold we were about to make revision 99.  The procedure for releasing a program for manufacture entailed assigning a <unique name> Revision 0 by NASA <part number>.  The Revision Number had to be 0 and the author had to be NASA with the manufacture part number included.  So we chose Lum99 Revision 0 by NASA <part number>.  We had previously got the part number from Bob Millard in the Program Office.  The LM part numbers were in the 2 million series (if I remember correctly) and CM numbers were one million.  We had just made LUMINARY Revision 99 when Dan Lickly, our chief engineer, came into the room with the news that the ephemeris numbers had to be updated.  This seemly upset my desire to keep the revision number under 100. But the Yul system was flexible.  We changed the name to LUM99R1, and since it took 2 to get the ephemeris numbers right, the final listing is named LUM99R2 Revision 0 by NASA <part number>.  So if you have a listing of what you think is the landing program for Apollo 11, look at the name, revision, and author to make sure.  I did not keep a copy ( I wish I had).  The mainline development of Luminary for subsequent missions continued with revision 100.
But wait, if Jim is right (and he's quite insistent about it!), then the software version we claimed above was flown on Apollo 11 may not have been the version actually flown, since it's rev 1 rather than rev 2.  And yet, rev 2 doesn't match any of the documentation we've found that purports to list the flown versions!  So in the end, we just don't know who is right.  We can tell you that the MIT Museum version we have here can indeed be used for simulated Apollo 11 lunar landings using the Orbiter spaceflight simulator with the NASSP plug-in, without any unseemly errors occurring.

But regardless of which version actually flew, whether rev 1 or rev 2, Jim's story is certainly correct in one very important regard, namely that the ephemeris data in Luminary 99 Rev 1 is certainly wrong.  How do we know this?  Well, ephemeris data in an AGC program covers the timespan of a year, beginning on July 1 of one year and continuing through June 30 of the following year, and so the missions in the time range July 1, 1969, through June 30, 1970, should all have the same ephemeris data.  Those missions happen to be Apollo 11, Apollo 12 , and Apollo 13.  The ephemeris data is roughly the last 50 lines of the CONTROLLED CONSTANTS in the Luminary source code, or in this case

and it's pretty easy to see that there's a mismatch between Luminary 99 Rev 1 and the other two.  Nor, as Jim's story would suggest, does it match Apollo 10 (Luminary 69), from the preceding 12-month interval.

At any rate, no printout of LUM99R2 has ever been found, nor any other reference to it other than Jim's recollection, so we can't present you with a bunch of scanned pages for it the way we can with all the other AGC listings we've made available.

One thing we may be able to do is to recreate LUM99R2 for you.  You see, if the only difference between Luminary 99 Rev 1 and LUM99R2 is the ephemeris, and since the correct ephemeris must agree with Luminary 116, then we can simply patch the correct ephemeris into the Luminary 99 Rev 1 source code ... which is precisely what we've done in the source-code hyperlink to the left!  Whether it's right or wrong, or whether it was actually flown in Apollo 11, we don't know.  But you can fly it in Virtual AGC if you like.

Apollo 12
LM-6
H
Luminary 1B
116
As colorized, hyperlinked  HTML

or

Reduced-size  scanned JPG
(300MB)

or

High-quality scanned JPEG 2000
(700MB)
Excerpted LM Systems Handbook

Operational Data Book
Flight Plan

Spacecraft Operational Trajectory

Programmed Guidance Equations for Luminary 1B
This is from the hardcopy in Don Eyles's private collection, as scanned at archive.org (sponsored, by Ron Burkey, me).  Unfortunately, the printout is pretty faint, and pp. 217-220, 226 are entirely missing.  But we've worked around the missing pages and have been able to completely reconstruct them.

Regarding the Programmed Guidance Equations document hyperlinked at the left, it is an MSC document whose purpose is "to provide more effective identification and analysis of various program performance features and to permit more effective review of published computer program documentation".  In other words, while it does contain material related to guidance equations, it is perhaps better to think of this as being a pseudo-code description of the Luminary 116 program.
Apollo 13
LM-7
H-2
Luminary 1C
131A/1
As colorized, hyperlinked,  HTML

Scanned page images from HRST (very big, very poor quality!)

Scanned page images, Don Eyles (very big, medium quality!)

Scanned page images, Don Eyles (very very big, good quality!)
GSOP (R-567)

Users' Guide to Apollo GN&CS Major Modes and Routines, Rev 1

Pad loads for LM-7

Excerpted LM Systems Handbook

Operational Data Book

Programmed Guidance Equations for Luminary 1C

Unfortunately, the version we have here is not quite the version flown in Apollo 13, though for many years we thought it was.  Niklas Beug was sharp enough to notice what I was not, namely in the table from document R-700 shown at the top of this very web-page that what we have is the first version (December 1969) of Luminary 131, but that subsequent versions were released in January and February 1970, and it was the latter of which that was flown.  Well ... we have what we have, and not necessarily precisely what we'd want to have in an ideal world!

In the early years of this project (2003-2016), we relied on a scanned PDF of Luminary 131 that had appeared on the now-defunct History of Recent Technology (HRST) website.  We're not entirely sure of the history of that scan, though there is a great cover letter from original AGC developer Jim Kernan that goes with it. What we are pretty sure of is that David Craig, apparently a great collector of AGC artifacts, asked for an AGC program listing, got this one (possibly xeroxed by Hugh Blair-Smith according to one theory), and that Gary Neff scanned it, passing the scans along to the HRST website administrators.  Unfortunately, the image quality became severely compromised after that point ... but whatever the image quality, we have to be grateful to all of these folks, because it was really the existence of this scan that made our entire Virtual AGC project possible.  Thanks, guys!  Gary Neff also later kindly provided me with a replacement for a page which is garbled in the HRST version.  This original scan is still available, linked at the left as "Scanned page images from HRST".

Nevertheless, however grateful we may feel for the HRST version, we're luckier today to have an infinitely superior scan, made for us from the personal collection of AGC developer Don Eyles, and scanned for us by archive.org.  A few pages (1728-1734) happen to be missing from Don's copy, and I've simply inserted them from the HRST copy.

Finally ... we can tell that these two different scans actually came from the same physical copy.  This makes sense from Jim Kernan's cover letter to David Craig, which says that Don Eyles supplied it.  However, if you try to check the scans for the hand-written notes that appear on many of the AGC listings, you soon realize that the HRST version doesn't have the notations that the Eyles version has, which is at first blush is impossible from the same printout!  Well, if you're persistent enough, you do eventually find notations that appear on both of them.  (Look on page 750.)  So the conclusion must be that Don (or somebody) wrote in most of these notes after the HRST version was copied in 1991, rather than during the actual Apollo project.  Isn't that nice to think that the program was actually being read and deeply examined, instead of simply being forgotten on a shelf?

Regarding the Users' Guide hyperlinked at the left, it is "a comprehensive, user-oriented description of the APOLLO GN&C system ... revised as necessary to remain current", but not targeted at specific missions.  However, given that it is dated July 1970, it is probably pretty accurate for Apollo 13.

Regarding the Programmed Guidance Equations document hyperlinked at the left, it is an MSC document whose purpose is "to provide more effective identification and analysis of various program performance features and to permit more effective review of published computer program documentation".  In other words, while it does contain material related to guidance equations, it is perhaps better to think of this as being a pseudo-code description of the Luminary 116 program.  (On the other hand, Section 5 of the GSOP, "Guidance Equations", also hyperlinked at the left, does indeed cover this topic explicitly.)
Apollo 14
LM-8
H-3
Luminary 1D
178

Excerpted LM Systems Handbook

The solder ball

Users' Guide to Apollo GN&CS Major Modes and Routines, Rev 1

Apollo Guidance and Navigation Flowcharts, Program Luminary 1D (Rev 173):  Volume 1/2 and Volume 2/2

Operational Data Book
Regarding the Users' Guide hyperlinked at the left, it is "a comprehensive, user-oriented description of the APOLLO GN&C system ... revised as necessary to remain current", but not targeted at specific missions.  However, given that it is dated July 1970, it is probably pretty accurate for Apollo 14.
N/A
N/A
J
Luminary 1D
209


AGC developer Allan Klumpp retained a copy of Luminary 209, based on the the belief that it had flown on Apollo 17.  Unfortunately, this turns out not to have been the case, and it was really Luminary 210 that flew (see below).  But that doesn't invalidate the value of Luminary 209.  We'd still like to scan it and present it for you here!

As it turns out, the printout was donated to klabs.org before we could get access to it, nor do we have access to it today, but perhaps we'll be able to scan it some day.
Apollo 15
LM-10
J-1
Luminary 1E 210


As colorized, hyperlinked,  HTML

or

Reduced-resolution  high-contrast black&white PNG
(300MB)

or

Reduced-resolution  scanned color JPG
(250MB)

or

High-resolution scanned JPEG 2000
(500MB)


LGC Data Cards

Program Notes

Delco Manual

GSOP (R-567)

Users' Guide to Apollo GN&CS Major Modes and Routines, Rev 4, Colossus 3 and Luminary 1E

Operations Handbook
Operational Data Book
Crew Debriefing

Flight Plan

Checklists
LM Familiarization Manual
Luminary 210 is what flew on Apollo 15-17.  The scan we have is taken from AGC developer Don Eyle's collection, as scanned by archive.org, and financially sponsored by our Jim Lawton.  Thanks, Jim!

Below, you can see a video made by Niklas Beug of a simulated Apollo 15 lunar landing, using this Luminary 210 AGC software and the Orbiter spaceflight simulator, with the NASSP 8.0 Apollo-mission add-on and our own AGC CPU simulator.  (A higher-resolution version is probably available if you go directly to YouTube.)


Regarding "digital simulation" of the Apollo 17 landing hyperlinked at the left, it is an Apollo-era computer run (not one done by our project!), also from Don Eyles's collection, scanned by archive.org, and financially sponsored by our Fabrizio Bernardini.  It includes things like the pad loads, position of the LM at any given time, what's displayed on the DSKY at those times, and so forth.

Regarding the Users' Guide hyperlinked at the left, it is "a comprehensive, user-oriented description of the APOLLO GN&C system ... revised as necessary to remain current", but not targeted at specific missions.  However, given that it specifically references Colossus 3 and Luminary 1E, that seems pretty specific to Apollo 15, 16, and 17.
Apollo 16
LM-11
J-2
Program Notes

GSOP (R-567)

Users' Guide to Apollo GN&CS Major Modes and Routines, Rev 4, Colossus 3 and Luminary 1E

Operations Handbook
Operational Data Book
Flight Plan

LM Familiarization Manual
Apollo 17
LM-12
J-3
Excerpted LM Systems Handbook

Program Notes

GSOP (R-567)

Users' Guide to Apollo GN&CS Major Modes and Routines, Rev 4, Colossus 3 and Luminary 1E

Operations Handbook
Operational Data Book
Crew Debriefing

Flight Plan

LM Familiarization Manual

Landing digital simulation:
(The data in this table originally came from on-line sources, but in the form shown contains many corrections supplied by Paul Fjeld.  Please don't take this information as authoritative!)

Source Code and Binary

Both source code and (independently derived) binary code are provided within the yaAGC tarball downlod.  The files are contained within a subdirectory named after the software version (such as "Luminary131").  The more important files supplied are these:

Filename.agc
Source code for major subdivisions of the Luminary program.
MAIN.agc
Organizer which treats all of the other assembly-language files (*.agc) as include-files, to form the complete program.
Filename.binsource
Human-readable form of the Luminary binary executable, as an octal listing.
Filename.bin
Binary executable created from binsource (octal listing) file.

In other words, to create a Luminary binary executable rather than using the one provided with yaAGC (such as Luminary131.bin), one simply needs to assemble the file MAIN.agc.  Typically, if all files remain organized the way they are in the yaAGC distribution tarball, the sequence of steps for doing so (from a command-line prompt) would be something like this:

cd Luminary131
../yaYUL/yaYUL --force MAIN.agc >Luminary131.lst

The listfile (Luminary131.lst) so produced is a bit more manageable than the scanned version at MIT's website, in that it is a hundredth the size and you can perform text-searches on it.  The binary so produced, MAIN.agc.bin, should be byte-for-byte identical to the binary (Luminary131.bin) provided with the yaAGC distribution.  Therefore, the following Linux command should reveal no differences between the two:

diff -s MAIN.agc.bin Luminary131.bin

(Replace "diff -s" with "fc /b" in Windows.) 

Technically speaking....

A point which may not be completely appreciated is that Luminary131.bin was not created from the assembly-language source files.  Therefore, the byte-for-byte equivalence mentioned above actually has some significance.  In fact, both the assembly-language source code and Luminary131.bin (or Luminary131.binsource) come from separate readings of the original Luminary assembly listing scan, so their equivalence provides an important check on validity.  (See below.)  The file Luminary131.bin was created from the human-readable/editable ASCII file Luminary131.binsource by means of the program Oct2Bin, with the following steps:

cd Luminary131
./Oct2Bin <Luminary131.binsource
mv Oct2Bin.bin Luminary131.bin

Admittedly, few people are likely to perform any processing of this kind unless contributing a new version of the Luminary code to the Virtual AGC project.

Validation

Validity of the Luminary 131 Source Code and of the Binary (Apollo 13)

I believe that the core-rope image (which is what is needed to actually run the Luminary software in the yaAGC CPU emulator) I've provided for Luminary 1C (build 131) is 100% accurate.  If you're not willing to take my word for that, and if the discussion in the preceding section doesn't convince you, an extended discussion of proofing and validation of the core-rope appears in the description of the Colossus software.

Validity of the Luminary 099 Code (Apollo 11)

The Luminary 099 page images became available after the Colossus 249 and Luminary 131page images had already been converted to source-code files, and prior to any other missions becoming available.  The conversion technique was very abbreviated compared to that of Luminary 131, as follows:
The binary thus produced by yaYUL is supplied in the source tree and used for regression testing.



This page is available under the Creative Commons No Rights Reserved License
Last modified by Ronald Burkey on 2017-03-20.

Virtual AGC is hosted
              by ibiblio.org