I was wondering how the Apollo guidance computer handled the radiation encountered in space

  • 4
    $\begingroup$ It handled it pretty well it seems $\endgroup$
    – uhoh
    May 15 at 3:37
  • 12
    $\begingroup$ The components of the Apollo system most susceptible to radiation effects were the astronauts. $\endgroup$
    – John Doty
    May 15 at 14:30
  • 3
    $\begingroup$ ... and the radiation was never the top source of errors. $\endgroup$
    – fraxinus
    May 15 at 21:49
  • 3
    $\begingroup$ Among other things, they radiation hardened the NOR gates in the AGC. ibiblio.org/apollo/Documents/HSI-208507.pdf $\endgroup$
    – rve
    May 16 at 8:58
  • $\begingroup$ @rve Nice find. Unfortunately they don't show numbers, but this seems to be about bulk damage causing leakage currents which sets in at several krad total dose - far above the lethal lethal level for astronauts. $\endgroup$
    – asdfex
    May 17 at 11:54

TL;DR: It was so busy getting stuff done, it didn't care.

Being old, slow, massive and inefficient (by any modern standards, not by those in 1965) is a huge benefit when it comes to radiation hardness.

Let's start with the memory: Changing a bit in current S(D)RAM cells is trivial - introduce a bit of charge in the wrong place and the bit is lost. This couldn't happen in the AGC: The program was stored in rope core memory - losing a bit means physically burning a wire, which can't happen due to radiation alone. The RAM was similar, the bits were stored in the magnetization of a macroscopic piece of ferrite. Changing this requires a proper signal shape and more energy typical radiation can deliver.

The main part of the processor was made out of discrete logic gates - the size of each of those was on the order of 100µm - compare that to the current size of about 30 nm. That means the area was larger by a factor of 9 million! This is also about the difference in charge needed to change the state of a transistor and particles that carry this amount of energy are exceedingly rare. On top of that, the voltage margins were huge, the AGC ran at 14V, ten times more than modern circuits.

To get around all remaining problems, the programming and physical structure of the CPU had additional safety checks and parity bits installed - but these were not so much because of possible radiation issues, but for errors introduced through noise and possible failures of components. After all, the time estimated until a real hardware fault occurred was estimated at around 1000 operating hours in the mid-60s. Soft-faults due to bits transmitted incorrectly inside the computer were even estimated to be an order of magnitude more likely. There are some numbers about this in the documents on this page.

  • 9
    $\begingroup$ Some references would be nice! $\endgroup$ May 14 at 18:05
  • 1
    $\begingroup$ @OrganicMarble Sources: My general knowledge of radiation effects, what I read about the AGC in the past years and the Wikipedia entry on the AGC... But I'd also like to see some real study about those old kinds of computers. $\endgroup$
    – asdfex
    May 14 at 18:11
  • 4
    $\begingroup$ @OrganicMarble Leslie Lamport wrote about the Byzantine Generals Problem in 1982. That is the seminal paper on fault tolerant computing (cited ~7500 times). We didn't know how to do that in the 1960s. $\endgroup$ May 15 at 0:28
  • 2
    $\begingroup$ @DavidHammen That paper might be about fault tolerance in general, but fault tolerant computing as in triple redundancy, parity bits and error correction codes was known and used in the 60s. $\endgroup$
    – asdfex
    May 15 at 8:55
  • 2
    $\begingroup$ @fraxinus That is 'gate' as in 'logic gate', not as in 'gate of a FET'. $\endgroup$
    – asdfex
    May 15 at 16:19

The Apollo Guidance computer (AGC) controlled the jet propulsion and thus maintained the spacecraft's altitude and navigation. As you pointed out, any defects or errors in the AGC could result in a crash or the crew becoming stranded in space. Once the spacecraft left Earth's atmosphere, the risks increased exponentially due to large amounts of radiation that could cause changes to the computer's memory. Two solutions were initially proposed but neither was actually used:

  • A triple redundant system was proposed so that all calculations would be carried out by three identical systems and a voting system would choose the correct information. However, a major con was that the weight of the three computers had to be carried on both the lunar lander and ascent stage and since each AGC weighed 32kg, it would add up quickly.
  • The second proposed option was to build in a error code checker that would have a fault detection system.
  • In the end, neither solution was used and instead a sturdy enclosure around the AGCs was used to protect it from radiation. They also had a built in manual override to ease the astronauts onboard.

Source: The Apollo Guidance Computer (AGC)

  • 3
    $\begingroup$ I'm very skeptical. The AGC used magnetic core memory, not prone to radiation-induced bit flips. Nor is RTL particularly susceptible. A "sturdy enclosure" isn't much of a shield against GeV particles. Is there an original document? Of course in the 1960's, there wasn't much knowledge of the environment and its effects, so perhaps there was not a truly rational engineering process going on. Even now, I see a fair amount of confusion in this area: I joke that the biggest effect is that the word "radiation" turns brains to mush. $\endgroup$
    – John Doty
    May 15 at 14:04
  • 2
    $\begingroup$ The source is a Dutch business attorney firm. This site prefers sources that are more authoritative. I haven't found any NASA documents attesting to the AGC having a radiation shield. $\endgroup$ May 15 at 19:40

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.