Decoding Rediscovered Rope Memory From the Apollo Guidance Computer

On August 25th, 1966, an Apollo Command Module was launched aboard a Saturn IB rocket in mission AS-202. This mission was intended to immediately precede the ill-fated Apollo 1 mission, the AS-202 was unmanned, serving as a test of flight hardware, fuel cells, and the guidance and navigation control systems. This mission used the first Apollo Guidance Computer ever flown, and this mission was vital to testing the computer that would take men to the moon.

While the software from the later missions exists and is available on Github, the earlier Block I spacecraft, including the unmanned Apollo 4 and Apollo 6 missions, are poorly documented. [Francois Rautenbach] was lucky enough to get his hands on the rope memory modules from the AS-202 mission. Now he’s investigating these modules with oscilloscopes and x-rays to recreate some of the first software that was flown in space.

The procedure to extract the data from these rope memory modules is a bit harder than reading a bit of Flash off a chip. Rope memory is weird, but with a contraption made out of a lot of relays and an oscilloscope, [Francois] was able to capture data from these memory modules.

Of course, [Francois] first needed to figure out the pinout for the gigantic backplane connector on each of these memory modules. To do that, he checked out a Block II AGC, read the schematics very carefully, and reverse engineered a connector that isn’t made anymore. The next step was x-raying the rope memory modules to see how they were assembled. Even though these memory modules contain the only extant copy of the Block I AGC software, even reading one bit off of these modules is an amazing case of technological archeology.

The answer to the obvious question — where did these modules come from — is exactly what you would expect. These memory modules were picked up off a scrap heap forty years ago. The gentleman who found these modules was kind enough to give them to [Francois]. Check out the videos below for [Francois]’ video logs. If you’re into slightly more destructive testing of forgotten Apollo flight hardware, [Fran Blanche] tore down a few modules from the Apollo Launch Vehicle Digital Computer a few years ago.

Thanks to [Vincent], [Danie], and [Kent] for jumping on this one and sending it into the tip line.

38 thoughts on “Decoding Rediscovered Rope Memory From the Apollo Guidance Computer

  1. Looking up this technology, I find a similarity to a system used in early UK “Electronic” telephone exchanges (TXE2 I think) that had many ferrite cores (large, like used in “old school” TV’s, for the EHT supply) that were threaded by many wires, each representing a unique telephone number, or line ID. That would have been sometime in the mid 70’s. Not a new idea then… I think this is a picture of such a thing. The cores are in the middle on the right. I think. (Vague memory from some 40 years ago!!) I’ll have to try and visit that place…

  2. Gearhart industries, in the 1980’s used Ratheon RDS550 (I think) Computers in oil field logging trucks. Core Memories were also used. I bet that these old computers can be found today, with documentation on the programming etc. Might overlap your “Rope” memories considerably. They were VERY reliable machines!

      1. In the old factory montage from the Youtube video, in the article, it appears that the data in the rope memory is hardwired when the data bus wires are sown into the modules. How does that work? I thought that data was written as magnetisation of the cores and thus volatile, or at least semi volatile, not 50 years data retention ?

        Secondly, how does 512 ferrite cores equal 65Kb capacity?


        1. More than one wire can pass through each ferrite bead.
          Wikipedia claims up to 64 wires could fit per bead on the AGCs rope memory. (ROM)
          They don’t store memory in the bead, it’s more that where there is a bead a signal can pass because it is being used a a transformer.

  3. Tagged these to watch later!!
    What i would like to know is how and why did these end up on a scrap heap?
    Did NASA pull the data and archive it somewhere? if its avail to compare that would be cool.
    Thanks for this, very interesting!

    1. When they were tossed they were obsolete. They couldn’t be repurposed and they were part of a fast-moving program that would eventually involve half a million people in various roles. At the time there was no such thing as retrocomputing or computer archaeology; there was just computing that worked and computing that didn’t, and once they moved to Block II these were computing that no longer worked, so there was no reason to keep them around.

  4. There’ll be hundreds of people who’ve worked with rope memory, although the number of them still above ground and breathing isn’t getting any larger.

    Core rope is a form of ROM. Sacrificing understandableness for compactness. Basically it’s like core RAM, except some of the cores are missing. That’s how you tell 0 from 1, whether the core’s there or not. Driving it should be a lot like driving core RAM.

    Also, as long as you don’t go mad with the voltages, it should be pretty bombproof. The cores are either physically there or they aren’t, and they’re macroscopic, around 1mm or so across. Should be arranged as an X-Y grid, with sense wires running diagonally through each core. Relatively speaking it should be one of the simpler things you can do with 1960s computer technology. Of course relatively speaking a rocket is just a big tin with fire coming out of one end.

    Alt.folklore.computers is still going on Usenet, far as I know, oblivious to the fads of the outside Internet. That’s where the real geezers who ran the big iron live. The ones with three-letter names, the timeless ones like DMR, one of the inventors of C and Unix. He was on a.f.c back when he was still online, oxygen-wise. If I were this guy, I’d definitely go there. That’s the most useful advice anyone can give.

    It’s not actually folklore, it’s just technology from the time of the Greek gods. Some of it works pretty well as folklore though. Great group.

      1. Both of these techniques existed.

        The basic x-y grid matrix with all cores populated could then be used as core RAM by passing a sense wire through all cores (ferrite beads) or the very same x-y grid could be used as core ROM but only passing the sense wire through the ferrite beads that needed to be ‘1’. The drive and sense electronics was different for the RAM / ROM modes.

        The above method was more economical to produce but was less reliable. In mission critical core rope the ferrites were completely removed to represent ‘0’.

        All of this is from memory so please (politely) correct me if I have something wrong.

      2. The “presence or absence of a core” is actually which cores the sense wire goes through ‘or not’. If the sense wire goes through a core that relates to the address (bus) then the core is “present”. If the sense wire does not go through a core that relates to an address then the core is “absent” so it is reversed in that it’s not about if the ‘core ferrite’ is present but instead it’s about if the ‘sense wire’ goes through the relevant core.

        There is a bit of data compression happening here compared to RAM. Weight is everything in the airspace industry so naturally they don’t use significantly more cores (ferrite beads) than are necessary so it comes down to which cores are re-usable for other ‘bits’.

        You can’t use the same core for two bits of the same byte obviously. You can’t use the same core for two bits that have one flipped bit in the address etc but you can reuse a lot of the cores because the stored data has nowhere near the entropy of the address space as you would expect in RAM.

        In RAM you may have 8192 bits that are either ‘1’ or ‘0’ and can change at any time. In ROM you have so many ‘1’ and so many ‘0’ and that doesn’t change.

    1. ” That’s how you tell 0 from 1, whether the core’s there or not.”
      It was always my understanding that a 1 or a 0 was stored depending on the direction of the toroidal core’s magnetization current, and further, that reading a core is a destructive process such that reading a core’s data requires an immediate re-write of the data found there. This is why one sometimes finds a core memory’s read cycle referred to as a “read-rewrite” cycle.

        1. “core ROM” trips so easily off the tongue, doesn’t it?
          In all my years of working with computers, I have never seen, nor heard of, “core ROM”. I can honestly say that, until today, I have never heard of anything in the electrical engineering, electronics or computer design field called “core ROM”.
          Given the basic physics of core memory’s operation, a core-memory ROM makes no sense.
          Some mainframe and minicomputer core memory examples are needed, if you please.

          p.s.: remember one fact: when read, data is destroyed in core memory.

          1. Honeywell information systems had at least two examples of Core ROM memories . In the H400 and H1400 computers, they had a device called “The Snake” a 22 foot long, three inch thick rope made of upwards of 1600 wires with 3/8″ cores spread out through the rope, and up to 16 wires threading each core. This device mechanized the complete instruction set, and it sat on top of the CPU bays coiled like a long S…thus the name The Snake.

            The H4200 system also had a small core ROM, which acted like a boot loader, but this was not a Core rope memory. In the H4200 , the core ROM was laid out in typical XY axis fashion like any other core memory. What made it ROM, was the fact that the cores were only driven with 190 to 200 mamps of current (vs 360 mamps in a typical XY read/write core memory) . This produced enough of a disturbance to be sensed by the sense amp, but not enough to flip a 0 core to a 1 or flip a 1 core to 0 . This memory was very touchy, and the backplane pins were tiny, so we had to use flags on the oscilloscope tips to troubleshoot. Invariably we would forget a flag on a pin, close it up and fire up the large computer only to start getting ROM errors immediately. The flag acted like an antenna, and the sense signal was so weak, that the radio noise picked up by the flag, was enough to attenuate the signal and cause an error.

    1. What’s even more embarrassing is that NASA didn’t bother to keep decent enough records that a mere 50 years later the computer programs that were involved in some of the most historically significant events in history are all but lost.

  5. This is great to see! We have done similar things with 1960’s and 70’s NASA technology. We call this technoarchaeology!

    We have spent many years recreating this old tech and I know where the manuals for this are…. Just contact us….

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s