Bad relay: Fixing the card reader for a vintage IBM 1401 mainframe

As soon as we finished repairing a printer failure at the Computer History Museum, Murphy's law struck and the card reader started malfunctioning. The printer and card reader were attached to an IBM 1401, a business computer that was announced in 1959 and went on to become the best-selling computer of the mid-1960s. In that era, data records were punched onto 80-column punch cards and then loaded into the computer by the card reader, which read cards at the remarkable speed of 13 cards per second. This blog post describes how we debugged the card reader problem, eventually tracking down and replacing a faulty electromechanical relay inside the card reader.

The IBM 1402 card reader at the Computer History Museum. Cards are loaded into the hopper on the right. The front door of the card reader is open, revealing the relays and other circuitry.

The card reader malfunction started happening every time the "Non-Process Run-Out" mechanism (NPRO) was used. During normal use, if the card reader stopped in the middle of processing, unread cards could remain inside the reader. To remove them, the operator would press the "Non-Process Run-Out" switch, which would run the remaining cards through the reader without processing them. Normally, the "Reader Stop" light (below) would illuminate after performing an NPRO. The problem was the "Reader Check" light also came on, indicating an error in the card reader. Since there was no actual error and the light could be cleared simply by pressing the "Check Reset" button, this problem wasn't serious, but we still wanted to fix it.

Control panel of the 1402 card reader showing the "Reader Check" error. The Non-Process Run-Out switch is used to run cards out of the card reader without processing them.

To track down the problem, the 1401 restoration team started by probing the card reader error circuitry inside the computer with an oscilloscope. (The card reader itself is essentially electromechanical; the logic circuitry is all inside the computer.) The photo below shows the 1401 computer with a swing-out gate opened to access the circuitry. Finding a circuit inside the IBM 1401 is made possible by the binders full of documentation showing the location and wiring of all the computers circuitry. This documentation was computer generated (originally by a vacuum tube IBM 704 or 705 mainframe), so the diagrams were called Automated Logic Diagrams (ALD).

The IBM 1401 with gate 01B4 opened. The yellow wire-wrapped wiring connects the circuit boards that are plugged into the gate. The computer's console is visible on the front of the computer.

The reader check error condition is stored in a latch circuit; the latch is set when an error signal comes in, and cleared when you press the reset button. To find this circuit we turned to the ALD page that documented the card reader's error checking circuitry. The diagram below is a small part of this ALD page, showing the read check latch of interest: "READ CHK LAT". Each basic circuit (such as a logic gate) is drawn on the ALD as a box, with lines showing how they are connected. Inside the box, cryptic text indicates what the circuit does and where it is inside the computer. For example, the latch (lower two boxes) is constructed from a circuit card of type CQZV (an inverter) and a CHWW card (a NAND gate). The text inside the box also specifies the location of each card (slots D21 and D24 in gate 01B4), allowing us to find the cards in the computer. Note that the RD REL CHK signal comes from ALD page 56.70.21.2; this will be important later.

The read check latch circuit, excerpted from the ALD 36.14.11.2.

The schematic below shows the latch redrawn with modern symbols. If the RESET line goes low, it will force the inverted output high. Otherwise, the output will cycle around through the gates, latching the value. If any OR input is high (indicating an error), it will force the latch low. Note the use of wired-OR—instead of using an OR gate, signals are simply wired together so if any signal is high it will pull the line high. Because transistors were expensive when the IBM 1401 was built, IBM used tricks like wired-OR to reduce the transistor count. Unfortunately, the wired-OR made it harder to determine which error input was triggering the latch because the signals were all tied together.

The read check latch circuit redrawn with modern symbols.

Once we located the circuit cards for the latch, we used an oscilloscope to verify that the latch itself was operating properly. Next, we needed to determine why it was receiving an error input. After disconnecting wires to get around the wired-OR, we found that the error was not coming from the Read/punch error or the Feed error signal. The RD REL CHK was the obvious suspect; this signal was part of the optional Read Punch Release feature1. However, the team insisted that Read Punch Release wasn't installed in our 1401. The source of this signal was ALD 56.70.21.2 and
our documentation didn't include ALD section 56, confirming that this feature wasn't present in our system.

Additional oscilloscope tracing showed a lot of noise on some of the signals from the card reader. This wasn't unexpected since the card reader is built from electromechanical parts: relays, cam switches, brushes, motors, solenoids and other components that generate noise and voltage spikes. I considered the possibility that a noise spike was triggering the latch, but the noise wasn't reaching that circuit.

The plug charts show the type of card in each position in the computer, and the function assigned to it. This is part of the plug chart for gate 01B4.

At this point, I was at a dead end, so I took another look at the RD REL CHK signal to see if maybe it did exist. The 1401's documentation includes "plug charts," diagrams that show what circuit card is plugged into each position in the computer. I looked at the plug chart for the card reader circuitry in gate 01B4 (swing-out gate, not logic gate). The plug chart (above) showed cards assigned to the mysterious ALD 56.70.21.2, such as the cards in slots A15-A17 and B15. (The plug chart also had numerous pencil updates, crossing out cards and adding new ones, which didn't give me a lot of confidence in its accuracy.) I looked inside the computer and found that these cards, the Read Punch Release cards generating RD REL CHK, were indeed installed in the computer. So somehow our computer did have this feature.

The gate in the 1401 holding the card reader circuitry. Note the cards in positions A15 and B15.

The problem was that even though these cards were present in the system, we didn't have the ALDs that included them, leaving us in the dark for debugging. I checked the second 1401 at the Computer History Museum; although it too had the cards for Read Punch Release, its documentation binders also mysteriously lacked the section 56 ALDs. Fortunately, back in 2006, the Australian Computer Museum Society sent us scans of the ALDs for their 1401 computer. I took a look and found that the Australian scans included the mysterious section 56. There was no guarantee that their 1401 had the same wiring as ours (since the design changed over time), but this was all I had to track down RD REL CHK.

Simplified excerpt of ALD 56.70.21.2 from an Australian 1401 computer.

According to the Australian ALD above, RD REL CHK was generated by the CGVV card in slot A17 (upper right box above). The oscilloscope trace below confirmed that this card was generating the RD REL CHK signal (yellow), but its input (RD BR IMP CB) (cyan) looked bad. Notice that the yellow line jumps up suddenly (as you'd expect from a logic signal), but the cyan line takes a long time to drop from the high level to the low level. Perhaps a weak transistor in a circuit was pulling the signal down slowly, or some other component had failed.

Oscilloscope trace showing the "circuit breaker" signal from the card reader (cyan) and the READ REL CHK error signal (yellow).

We looked into the RD BR IMP CB signal, short for "ReaD BRush IMPulse Circuit Breakers". In IBM terminology, a "circuit breaker" is a cam-operated switch, not a modern circuit breaker that trips when overloaded. The read brush circuit breakers generate timing pulses when the read brushes that detect holes in the punch card are aligned with a row of holes, telling the computer to read the hole pattern.

The NGXX integrator card contains resistor-capacitor filters. Unlike most cards, this one doesn't have any transistors. Photo courtesy of Randall Neff.

We looked up yet another ALD page to find the source of the strangely slow RD BR IMP CB signal. That signal originated in the card reader and then passed through an NGXX integrator card (above). Earlier I mentioned that the signals from the card reader were full of noise. This isn't a big problem inside the card reader since brief noise spikes won't affect relays. But once signals reach the computer, the noise must be eliminated. This is done in the 1401 by putting the signal through a resistor-capacitor low-pass filter, which IBM calls an "integrator". That card eliminates noise by making the signal change very slowly. In other words, although the signal on the oscilloscope looked strange, it was the expected behavior and not a problem. But why was there any signal there at all?

Part of IBM 1402 card reader schematic showing the cams (circles) that generate the CB read pulses and the relay that blocks the pulses during NPRO.

After some discussion, the team hypothesized that the pulses on RD BR IMP CB shouldn't be getting to the 1401 at all doing a Non-Process Run-Out, since cards aren't being read. The schematic4 for the card reader (above) shows the complex arrangement of cams and microswitches that generates the pulses. During an NPRO, relay #4 will be energized, opening the "READ STOP 4-4" relay contacts. This will stop the BRUSH IMP CB pulses from reaching the 1401.53 In other words, relay #4 should have blocked the pulses that we were seeing.

Frank King replacing a bad relay in the 1402 card reader. The relays are next to his right shoulder.

The card reader contains rows of relays; the reader's hardware is a generation older than the 1401 and it implements its basic control functions with relays rather than logic gates. Frank pulled out relay #4 and inspected it.6 The relay (below) has 6 sets of contacts, activated by an electromagnet coil (yellow) and held in position by a second coil. Springs help move the contacts to the correct positions. One of the springs appeared to be weak, preventing the relay from functioning properly.7 Frank put in a replacement relay and found that the card reader now performed Non-Process Run-Outs without any errors. We loaded a program from cards just to make sure the card reader still performed its main task, and that worked too. We had fixed the problem, just in time for lunch.

The faulty relay from the IBM 1402 card reader.

Conclusions

It is still a mystery why section 56 of the ALDs was missing from our documentation. As for the presence of the Read Punch Release feature on our 1401, that feature turns out to be standard on 1401 systems like the ones at the museum.8 I think the belief that our 1401 didn't include this feature resulted from confusion with the Punch Feed Read feature, which we don't have. (That feature allowed a card to be read and then punched with additional data as it passed through the card reader.)

The team that fixed this problem included Frank King, Alexey Toptygin, Ron Williams and Bill Flora. My previous blog post about fixing the 1402 card reader is here, tracking down an elusive problem with a misaligned cam.

I announce my latest blog posts on Twitter, so follow me at @kenshirriff for future articles. I also have an RSS feed. The Computer History Museum in Mountain View runs demonstrations of the IBM 1401 on Wednesdays and Saturdays so if you're in the area you should definitely check it out (schedule).

Notes and references

1. Read Punch Release was a feature to allow the CPU to operate while reading a card. IBM's large 7000 series mainframes used "data channels," which were high-performance I/O connections using DMA and controlled by separate I/O processors. With a data channel, the CPU could process data while the channel performed I/O. But the 1401 was a much simpler machine, designed to replace electromechanical accounting machines that would read a card, process the card, and print out results. On the 1401, when the CPU executed an instruction to read a card, the CPU would wait while the card moved through the card reader and passed under the brushes to be read. The mechanical cycle to read a card took 75 ms (corresponding to 800 cards per minute), of which only 10 ms was available for the CPU to perform computation and the rest was wasted (from the CPU's perspective). The Read Punch Release feature was a workaround for this. The programmer could issue an SRF (Start Read Feed) instruction, which would cause a card to start moving through the card reader. The program had 21 ms to perform computation and execute the read instruction before the card reached the reading station. (If the program executed the read instruction too late, the computer wouldn't be able to read the card and would halt with an error.) This provided extra computation time in each card read cycle. IBM charged a monthly fee for additional features; Read Punch Release was relatively inexpensive at $25 per month (equivalent to about $200 today). ↩

2. The Read Punch Release feature also provided a similar instruction for punching a card, allowing an extra 37 ms of computation while punching a card. See page 16 of the IBM 1402 Card Read-Punch Manual for details on card timing and the read punch release operation. ↩

3. The card reader schematic shows that six separate cams were required to generate the RD BR IMP CB signal. The problem is that cards are read at high speed, so rows on the card are read just 3.75 ms apart. Cams and microswitches are too slow to generate pulses at this rate. To get around this, pulses for odd rows and even rows are generated separately. In addition, one set of switches closes for the start of a pulse and a second set opens for the end of a pulse. Needless to say, it is a pain to adjust all these cams so the pulses have the right timing and duration. If this timing is off, cards won't read correctly.

   To improve reliability and reduce maintenance, IBM eventually replaced these cams with a "solar cell" (i.e. a photo-cell), slotted disk, and light. The light passing through the slotted disk triggered a pulse from the photo-cell. Our ALDs had some penciled-in modifications suggesting that our 1401 was originally configured to work with a solar cell card reader and then modified to work with the older circuit breaker card reader. ↩

4. The schematic for the 1402 card reader is here. The read brush impulse CB signal is generated on pdf page 8. This document also includes instructions on how to upgrade from the "circuit breaker" circuit to the "solar cell" circuit, a change that is indicated as taking 1.0 to 1.5 hours for the hardware installation, 1.5 to 2.0 hours for miscellaneous electrical changes, and 2.3 to 3.7 hours to wire up the new circuit. (See pdf pages 47-53.) ↩

5. The relays involved in an NPRO operation are documented in 1402 Card Read-Punch Customer Engineering Manual of Instruction, page 4-3 or pdf page 31. ↩

6. The relay is a "permissive make" relay, a type of relay that IBM designed to be twice as fast as regular relays. For a detailed discussion of IBM's relays, see Commutation and Control. The permissive make relay is discussed on page 59 (pdf page 18). ↩

7. Stan Paddock on the 1401 team built a relay tester that we could use to check the bad relay. Unfortunately, the 1401 workshop at the Computer History Museum is closed due to construction so we couldn't access the tester (or the collection of spare relays in the workshop). Fortunately, we had a spare relay that wasn't in the workshop for some reason. ↩

8. The IBM Sales Manual lists the various 1401 features and their prices (pdf page 50). It states the Read Punch Release feature is standard on the 1401 Model C, the "729 Tape/Card System". ↩

The printer that wouldn't print: Fixing an IBM 1401 mainframe from the 1960s

The Computer History Museum has two operational IBM 1401 computers used for demos, but a few weeks ago one computer suddenly couldn't print anything. I helped track down the problem, but it was more tricky than we expected; along the way we had to investigate the printer error checking circuits, the print buffer, and even low level core memory signals. This blog post discusses our investigation and how we traced the problem to a failed germanium transistor.

The IBM 1401 mainframe computer (left) at the Computer History Museum printing the Mandelbrot fractal on the 1403 printer (right).

The IBM 1401 computer was announced in 1959, and went on to become the best-selling computer of the mid-1960s, with more than 10,000 systems in use. The 1401 leased for $2500 a month (about $20,000 in current dollars), a low price that let even medium-sized businesses use the 1401 for payroll, accounting, invoicing, and many other tasks. The IBM 1401 computer was constructed from small circuit boards (called SMS cards) plugged into units called "gates"—these are gates in the sense of something that swings open, not logic gates. The photo below shows the 1401 with one of the gates open, revealing dozens of brown SMS cards plugged into the gate.

The IBM 1401 computer, with one of the gates opened, showing the dozens of circuit boards (SMS cards) in each gate. The fan on the front of the gate keeps the cards cool.

One key selling point of the IBM 1401 was its high-speed line printer (the IBM 1403), which could hammer out 10 lines per second. (IBM claimed this was four times as fast as competing printers, but others dispute this.) The 1403 printer had excellent print quality, said to be the best printing until laser printers were introduced in the 1970s.1 IBM claims that "Even today, it remains the standard of quality for high-speed impact printing."

Closeup of the type chain (upside down) for an IBM 1403 line printer.

The 1403 printer used a chain of type slugs (above) that rotated at high speed above the paper, with an inked ribbon between the paper and the chain. Each of the 132 print columns had a hammer and an electromagnet. At the right moment, when the desired character passed the hammer, the electromagnet drove the hammer against the back of the paper, causing the paper and ribbon to hit the type slug, printing the character.2

Printing mechanism of the IBM 1401 line printer. From 1401 Reference Manual, p11.

Unfortunately, the printer at the Computer History Museum recently had a problem: whenever a line was printed, the computer would halt due to a "print check" error. Fortunately the museum has a team of volunteers to help keep the system running; people helping with this printer problem included Ron Williams, Frank King, Marc Verdiell, Carl Claunch, Michael Marineau, Robert Garner and Alexey Toptygin. By the time I arrived to help, Ron had written a simple test program that repeatedly attempted to print a line; he toggled the program into the computer by hand, and he disabled the error check. The printer printed the characters properly, so we suspected the problem was in the error reporting circuitry inside the computer. Our strategy was to find the error signal and then trace it back through the computer to determine why it was being generated.

We started by examining the latch circuit that holds the print check error condition and sends it to the rest of the computer. To find the circuit, we consulted the documentation: binders of cryptic computer-generated wiring diagrams, called Automated Logic Diagrams (ALD). A small piece of an ALD is shown below showing the print check latch (PR CHK LAT). Each box on the ALD corresponds to a circuit on an SMS board and the lines show how the boards are wired together. Deciphering the text inside the box on the right indicates a board of type 2JMX implementing a "2+AO" function, which in modern terms is AND-OR-Invert. The text in each box also indicates the location of the card: its gate (physical swing-out gate, not logic gate), gate 01A6 in this case, and the card's position in the gate (F10). Thus, to check the output (labeled H) of the latch with the oscilloscope, we swung out gate 01A6, found card F10, and hooked the oscilloscope to pin H. We found pin H went low (error) when pins F and G went high, which was the proper behavior for the latch. Pin G (PR CK SAMPLE) was essentially a clock to sample the error state, while pin F was the error signal itself. Our next task was to determine what was triggering the error signal on pin F.

Excerpt of an Automated Logic Diagram (ALD) for the IBM 1401, showing the print check latch (PRT CHK LAT). This page is denoted 36.37.21.2.

The documentation also includes logic diagrams that show the circuitry at a logical level, which is slightly easier to understand than the physical connections on the ALD diagrams. The logic diagram below shows the printer error circuitry. At the right, the print check error signal (PRT CHK ERROR) comes out of the latch (PR CHK LAT) that holds the error signal. (This is the same latch as in the ALD diagram above, and you can match up the signal names.) To the left of the latch, several different error conditions are detected and combined to form the error signal fed into the latch. (Note that IBM's logic symbols didn't match standard symbols. The semicircle is an OR gate, not an AND gate. The triangle is an AND gate. An "I" in a box is an inverter.)

Logic diagram of the error checking logic for the IBM 1401/1403. From Instructional Logic Diagrams page 77 "Print Buffer Controls".

Several different conditions can trigger a print check error3 and we thought the "hammer fire" check was a likely candidate. Recall that the printer uses 132 hammers, one per column, to print a line of characters. To make sure the hammers are operating correctly, the computer has two special planes in core memory. (The 1401 contains 4,000 characters of core memory4; each bit of memory is a tiny ferrite ring that is magnetized one way to store a "1" and the other way for a "0". A grid of 4000 cores forms a plane, storing a 1-bit slice of memory. Multiple planes are stacked up to form the storage unit.) Each time the computer decides to fire a hammer, it records this in core memory in the "equal check" plane. When a hammer actually fires, the current pulse from the electromagnet stores a bit in the "hammer-fire" plane.5 Each print scan cycle, the computer compares the two core planes to see if a hammer was fired when it wasn't supposed to, or if a hammer failed to fire when it should have; a mismatch triggers the "hammer fire" check error.

Closeup of the hammer electromagnets in the IBM 1403 printer. An electromagnet (when energized through its pair of wires) pulls a metal armature, which drives the hammer, paper and ribbon against the type slug. There are 132 hammers, one for each column, arranged in two rows of 66.

After some difficulty6, we determined that the problem wasn't the hammer fire check, but a different check: "print line complete" (PLC). This check ensures that for each line, either exactly one character was printed in each column or the column was blank. This check uses a third special core plane, the "print line complete" plane. Each time a character is printed in a column, the corresponding bit is set. (For a blank or unprintable character, a separate circuit sets the column's bit.) At the end of the line (during scan 49), the print line complete cores are checked; if any core is zero, the printer failed to print that column and an error is reported. (You can see the PLC CHECK signal and the logic that generates it on the earlier logic diagram.)

Oscilloscope probing (below) showed that the PLC CHECK (yellow) was triggered because the system thought a second character was being printed in the same column. The cyan signal is the (inverted) PLC bit from core (PR LINE COMP LATCH); each low pulse indicates a character has been printed in that column. The pink pulse (PRINT COMPARE) indicates a new character is being printed. The problem is that the cyan and pink signals go low at the same time, indicating both an existing character and a new character in the column. This generates the extra blue pulse (PLC CHECK), which triggers the yellow pulse (PRINT CHK ERROR from the latch). (This circuit can be seen in the earlier logic diagram, labeled "Trying to print position twice".)

Oscilloscope trace from debugging the IBM 1401's printer.

Several things could cause the system to think two characters were being printed in the column. Looking at the printer's output we saw that it printed just the expected character on the paper, so the circuit to print a character seemed to be working correctly (PRINT COMPARE, the single pink pulse above), We tested the blank / unprintable circuit and it was detecting blank and non-blank columns correctly. So the most likely problem was reading a 1 from core memory (the cyan line above, PR LINE COMP LATCH) when it should be a 0. But was the problem the wrong value going in to core, or the wrong value coming out?

The logic diagram below shows the circuit that writes to the Print Line Compare core memory. At the right, PR LINE COMP INH is the (inverted) signal written to core.8 On scan 49 (the error-checking print cycle after printing all 48 characters), this line is set high, clearing the memory. If a character is being printed, the PRINT COMPARE EQUAL signal will set the core. At the left, logic gates detect a blank or unprintable character. And if a 1 bit was already in core (PR LINE COMP LATCH), the 1 bit is rewritten to core.

Logic diagram of the print line complete logic for the IBM 1401/1403. From Instructional Logic Diagrams page 77 "Print Buffer Controls".

We detected that this circuit was writing erroneous 1 bits to core because it was reading erroneous 1 bits from core. But that put us in a circle, not knowing if the initial problem was the read or the write. To resolve this, we triggered the oscilloscope on print scan 49, which is when the PLC bits get cleared, and then looked at the next print scan, which reads the cleared bits back. We saw 0's being written (i.e. PR LINE COMP INH high), but unexpectedly saw 1's coming back (PR LINE COMP LATCH). So we knew something was going wrong at a low level in the core memory.

I should mention that in the base 1401 system, the printer check bits were stored in the main core memory module, but our system used a separate "print storage" core memory for improved performance. The performance issue is due to how the printer uses core memory: each time a hammer lines up with a type slug, the computer reads the corresponding character from core memory and fires the hammer if the character in storage matches the character under the hammer. Since core memory is constantly in use while printing a line, the computer can't do any computation while printing. The solution was the print storage feature: an additional 132-address core memory that functioned as a print buffer.7 With print storage, a line to be printed was first rapidly copied from the main core memory to the print storage core memory. Then the computer could continue doing computation using the main core memory while the print circuitry read from the print storage core memory. Each option on the IBM 1401 had a monthly charge; IBM charged an extra $386 a month for the print storage feature.

This print storage gate has the circuitry to drive the printer buffer core memory. The core memory unit in the upper right has bundles of yellow wires attached.

The photo above shows the gate that implements the print storage feature. The core memory module is the block on the upper right with yellow wires attached. (Individual cores can be seen in the photo below.) Core memory requires a lot of supporting circuitry. To select an address, driver cards generate X and Y signals. To write a core, the inhibit signal is combined with the clock by a gate, and then a driver card amplifies the signal and sends it through the inhibit line that passes through all the cores in the plane.8 When a core is read, it induces a pulse on a sense wire. This pulse is amplified by a sense amplifier card, and then the bit is stored in a latch. The numerous SMS cards in the print storage gate provided these support functions.

The cores inside the print buffer. The wiring is not the usual core memory grid because each printer hammer is wired directly to a hammer check core. The image quality is bad because of the plastic cover over the cores.

We probed the sense amplifier and latch cards on the reading side of the core memory and they seemed to be operating correctly, so we moved to the writing side. The HN inhibit driver card seemed a candidate for failure since it operates at high current, but we swapped the card with a replacement and the printer still failed. Next, I tried looking at the input to that card, but found there was no signal on that line, which seemed very suspicious.

Oscilloscope of the bad "CHWW" NAND gate card: pink (3) and blue (4) are inputs, cyan (2) is the output, stuck high.

The missing signal was generated by a card of type CHWW, a NAND gate that combines the inhibit signal with the clock before sending it to the driver card. I hooked up the oscilloscope to the inputs and output of the NAND gate, yielding the trace above. This trace was the smoking gun: the output (cyan 2) remained high even when the two inputs (pink 3 and blue 4) went high. This showed that the NAND gate had failed and its output was stuck high. This explained everything: with this output stuck high, only 1's would be written to the PLC core plane. Then, when a character was printed, the print circuitry would read the 1 from core, think a character had already been printed in this column, the PLC check would fail, and the print check error would be triggered.

The printer successfully operating, printing out powers of 2.

We swapped this card with a spare, and the printer started printing without any errors (above). This proved that we had finally traced the problem; it was a simple NAND gate in the depths of the printer buffer core memory circuit. The failed card is shown below. It implements three NAND gates (details) using diode-transistor logic (which IBM calls CDTL—Complemented Transistor Diode Logic). Each two-input gate uses one germanium transistor (circular metal can) and two diodes (striped glass components on the right). Pull up resistors (striped) and inductors (beige) on the left complete the circuits.

The failed CHWW card from the IBM 1401. This card implements three NAND gates. The lower left transistor failed, and has been replaced.

I tested the card with a signal generator and found that while two of the three NAND gates worked, the other was stuck at a high output, confirming what we saw inside the 1401. Next I tested the transistors using the diode test mode on a multimeter. The good transistors had voltage drops of 0.23V. (This may seem low, but remember that these are germanium transistors not silicon transistors.) In comparison, the bad transistor had a Vbe drop of 0.95V, much higher. Finally, we removed the transistors and checked them on a vintage Tektronix 577 curve tracer. We thought the bad transistor might just be too weak to operate the gate, but it was entirely dead—totally flatlined on the curve tracer.

We opened up the transistor on a lathe and looked inside. The transistor is an IBM 083 NPN germanium alloy transistor (germanium was used before silicon transistors). The transistor consists of a tiny germanium die (the shiny metallic square below), forming the base. Two wires are attached for the emitter and collector, connected to dots of tin alloy, a larger dot on the front for the collector and a smaller dot on the back for the emitter. Under the microscope, it looked like there was some corrosion on the alloy dots and the emitter wire didn't look solidly connected, so we suspect that is the root cause of the failure.

Inside a failed IBM 083 germanium transistor. The silver-colored square in the middle is the germanium die, wired to the base pin. The dot in the middle is tin alloy, forming the collector, with a wire to the collector pin on the left. A smaller dot on the other side of the germanium die forms the emitter, wired to the pin on the right.

Conclusions

This was a harder problem to diagnose than most of the IBM 1401 issues. But we managed to track down the problem, replace the bad card, and get the printer back in operation. One nice thing about the IBM 1401 compared to modern systems is that it's not a black box—you can look inside all the circuitry, down to the individual transistors. In this case, we were able to find the bad transistor that was causing the system failure, and even determine that it was probably corrosion that killed the transistor.

I announce my latest blog posts on Twitter, so follow me at @kenshirriff for future articles. I also have an RSS feed. The Computer History Museum in Mountain View runs demonstrations of the IBM 1401 on Wednesdays and Saturdays so if you're in the area you should definitely check it out (schedule).

Notes and references

1. One reason for the IBM 1403's high quality printing was its use of a type chain instead of typebars or a drum. Many earlier line printers used rows of typebars or a rotating drum of characters. Any timing imprecision would change the vertical positioning of characters, yielding ugly wavy text. The 1403, on the other hand, used a horizontally rotating chain of characters so misalignment caused a hardly-noticeable change in the spacing between characters. ↩

2. You might expect that the 132 hammers align with 132 type slugs, so the matching hammers all fire at once, but that's not what happens. Instead, the hammers and type slugs are spaced slightly differently, so only one hammer is aligned at a time, and a tiny movement of the chain lines up a different hammer and type slug. (Essentially they form a vernier.) Specifically, every 11.1 microseconds, the chain moves 0.001 inches. This causes a new hammer / type slug alignment. For mechanical reasons, every third hammer lines up in sequence (1, 4, 7, ...) until the end of the line is reached; this is called a "subscan" and takes 555 microseconds. Two more subscans give each hammer in the line an option to fire, forming a print scan of 1.665 milliseconds. 48 print scans give each hammer a chance to print each character, and then the 49th print scan is used for error checking. (For more details of this timing, see Manual of Instruction, page 37.)

   The mechanism of scans and subscans may seem excessively complicated. But what it accomplishes is matching up the fast "electronic world" with the slower "mechanical world." Specifically, every 11.1 microseconds, a hammer and type slug line up. The computer reads the character in that column from core, compares it to the character on the type slug, and if they match, it fires the hammer. The important thing here is that a core memory cycle matches the time between hammer alignments, making it possible to read the character from core for each hammer alignment. If you want more information on how the print chain works, I have an animation here.

   One subtlety is that a hammer takes 1.52 milliseconds to impact (Manual of Instruction, p32). Thus, it's not really the case that the hammer fires when it lines up with the type, but when it will be lined up 1.52 milliseconds in the future. ↩

3. It may seem excessive that the 1401 had multiple checks to ensure that the printer was operating properly. But for a business computer, print errors could be catastrophic: imagine if a day's payroll checks had a digit printed wrong or tax forms were printed incorrectly. IBM's scientific computers had much less error checking than the business computers, on the assumption that scientists would notice problems. ↩

4. The 1401 stores 4,000 characters in core memory, not 4096, because it is a decimal machine (i.e. BCD), with decimal addresses. Its memory can be expanded to 16,000 characters with a dishwasher-sized memory expansion unit; I wrote about repairing this unit here. I wrote more about the 1401's core memory here. ↩

5. Recording each hammer fire in core memory isn't done by the computer writing to core memory. Instead, each hammer is physically wired directly to a particular core; 132 wires from the hammer electromagnets to the cores. When a hammer fires, the current pulse from the hammer's electromagnet goes through a wire wrapped through the corresponding core, magnetizing that core. (You can see these wires in the earlier picture of the cores.) ↩

6. It was tricky to determine which signal was triggering the error input F, due to the 1401's use of wired-OR. Because transistors were expensive when the IBM 1401 was built, IBM used many tricks to reduce the transistor count. One trick is the wired-OR—instead of using an OR gate, signals are simply wired together so if any signal is high it will pull the line high. Thus, We couldn't simply probe the signals feeding into pin F because they were all wired together. Instead, we needed to disconnect cards so we could test one signal at a time. ↩

7. The print storage core memory has 12 core planes; that is, it stores 12 bits at each location. Like a regular core location, it uses 6 bits to store each BCDIC character, as well as a bit for the word mark (metadata indicating field locations), and a parity bit. In addition, the print storage has four planes for error detection: a hammer fire sense plane (recording the hammers that fired), equal check plane (recording the hammers that should fire), print line complete plane (recording columns with a character printed), and an error check plane (indicating the column that triggered an error). ↩

8. The process to write to core memory may seem backwards, using a high signal on the inhibit line to write a 0. This is due to how cores function. The key that makes cores work is that they require a high current pulse to flip the core's magnetic state; a pulse with half the current has no effect on the core. Cores are arranged in a grid, with X and Y address lines that are pulsed to select a core. Multiple planes are stacked, one for each bit. Each line is pulsed with half the necessary current, so only the core where both lines cross has enough current to flip to the 1 state. Each plane has an inhibit line that passes through all the cores in the plane. To write a 1 to a plane, the inhibit line gets no current, causing the addressed core to flip to 1 as described. To write a 0 to a plane, the inhibit line gets half current in the opposite direction. The result is that none of the cores get enough current to flip, and the addressed core remains in the 0 state. Thus, by setting each plane's inhibit line appropriately, the desired 0's and 1's can be written to the address in the core stack. ↩

9. For information on how the print checks work, see Instruction Logic, page 98. The 1403 printer is documented in IBM 1403 Printer Component Description, 1403 Printers Field Engineering Maintenance Manual and 1403 Printers Field Engineering Manual of Instruction. See also this brief article about the 1403 printer in the IEEE Spectrum. For a detailed description of the IBM 1401, see IBM 1401: a modern theory of operation. ↩

Glowing mercury thyratrons: inside a 1940s Teletype switching power supply

We recently started restoring a Teletype Model 19, a Navy communication system introduced in the 1940s.14 This Teletype was powered by a bulky DC power supply called the "REC-30 rectifier". The power supply uses special mercury-vapor thyratron tubes, which give off an eerie blue glow in operation, as you can see below.

The thyratron tubes in the Teletype REC-30 power supply give off a blue glow. The orange light is a neon bulb used as a voltage reference.

The power supply is interesting, since it is an early switching power supply. (I realize it's controversial to call this a switching power supply, but I don't see a good reason to exclude it.) While switching power supplies are ubiquitous now (due to cheap high-voltage transistors), they were unusual in the 1940s. The REC-30 is very large—over 100 pounds—compared to about 10 ounces for a MacBook power supply, demonstrating the amazing improvements in power supplies since the 1940s. In this blog post, I take a look inside the power supply, discuss how it works, and contrast it with a MacBook power supply.

What is a Teletype?

A Model 19 Teletype. Image from BuShips Electron, 1945.

Teletypes are a brand of teleprinter, essentially a typewriter that could communicate long distances over a wire. You may be familiar with Teletypes from old newsroom movies, where they chatter out news bulletins, or you may have seen computers that used an ASR33 Teletype as a terminal in the 1970s. (Much of the terminology used by serial ports on modern computers dates from the Teletype era: start and stop bits, baud rate, tty, and even the break key.) Teletypes could also store and read characters by punching holes in paper tape, using a 5-bit code2 (below).

"Teletype is here to stay." This image shows the 5-hole paper tape used by Teletypes. Image from BuShips Electron, 1945.

Teletypes were introduced in the early 1900s. In that pre-electronic era, character selection, serialization, and printing were accomplished through complex electromechanical mechanisms: cams, electromagnets, switches, levers and gears. Pressing a Teletype key closed a combination of switches corresponding to the character. A motorized distributor serialized these bits for transmission over the wire. On the receiving side, electromagnets converted the received data bits into movement of mechanical selectors. The selector pattern matched the notches on one of the typebars, causing that typebar to move and the correct character to be printed.1

Partially disassembled Model 19 Teletype.

The current loop

Teletypes communicated with each other using a 60 milliamp current loop: if current is flowing, it's called a mark (corresponding to a hole in the paper tape), and if current is interrupted, it's called a space. Each character was transmitted by sending a start bit, 5 data bits, and a stop bit. (If you've used serial devices on your PC, this is where the start and stop bit originated. And the baud rate is named after Émile Baudot, inventor of the 5-bit code.) The REC-30 power supply produced 900 milliamps at 120V DC, enough current for a room of 15 Teletypes.
You might wonder why Teletypes don't just use voltage levels instead of the strange current loop. One reason is that if you're sending signals over a wire to the next city, it's hard to know what voltage they are receiving because of voltage drops along the way. But if you're sending 60mA, they'll be getting the same 60mA (assuming no short circuits). 3 The hefty current was necessary to drive the electromagnets and relays in Teletypes. Later Teletypes often used a 20 mA current loop instead of 60 mA.

Why a switching power supply

There are several ways of building a regulated power supply. The most straightforward is a linear power supply, which uses a component such as a tube or transistor to regulate the voltage. The component acts as a variable resistor, dropping the input voltage to the desired output voltage. The problem with linear power supplies is they are generally inefficient, since the extra voltage turns into waste heat.
Most modern power supplies, instead, are switching power supplies. They rapidly switch on and off, making the voltage averages out to the desired output voltage. Because the switching element is either on or off, not resistive as in a linear power supply, switching power supplies waste very little power. (Switching power supplies are usually much smaller and lighter too, but apparently the designers of the REC-30 didn't get that memo.4 The REC-30 is over two feet wide.) Most of the power supplies you'll encounter, from your phone charger to the power supply in your computer, are switching power supplies. Switching power supplies became popular in the 1970s with the development of high-voltage semiconductors, so tube-based switching power supplies are a bit unusual.

REC 30 Teletype power supply in its case painted Navy gray. The power cords exit the top. The tubes are behind the door on the right.

Inside the REC-30 power supply

The photo below shows the main parts of the REC-30 power supply. AC power enters at the left and is fed into the large autotransformer. The autotransformer is a special single-winding multi-tap transformer that converts the input AC voltage (between 95V and 250V)6 into a fixed 230V AC output. This allows the power supply to accept a variety of input voltages, simply by connecting a wire to the right autotransformer terminal. The 230V output from the autotransformer feeds the plate drive transformer, which outputs 400 volts AC to the thyratron tubes.5 The thyratron tubes rectify and regulate the AC into DC, which is then filtered by capacitors (not visible in photo) and inductors (chokes), to produce the 120V DC output.

REC-30 power supply, showing the main components.

Ignoring the switching for a moment, the AC-to-DC conversion in the REC-30 power supply uses a full-wave rectifier and center-tapped transformer (the drive transformer), similar to the diagram below. (The thyratron tubes provide rectification rather than the diodes in the diagram.) The transformer windings provide two sine waves, out of phase, so one will always be positive. The positive half goes through one of the thyratron tubes, producing pulsed DC output. (In other words, the negative half of the AC waveform is flipped to produce a positive output.) The power supply then smooths out these pulses to provide steady voltage, using inductors (chokes) and capacitors as filters.

A full wave rectifier circuit (center) converts AC (left) to pulsed DC (right). Image by Wdwd, CC BY 3.0.

Unlike the diodes in the diagram above, the thyratron tubes in the power supply can be controlled, regulating the output voltage. The basic idea is to turn the thyratron on for a fixed part of the AC cycle, as shown below. If it is on for the full cycle, you get the full voltage. If it is on for half the cycle, you get half the voltage. And if it is only on for a small part of the cycle, you get a small voltage.7 This technique is called phase angle control because it turns the device on at a particular phase angle (i.e. a particular point between 0° and 180°in the AC sinusoid). (This is very similar to a common light dimmer switch, which uses a semiconductor TRIAC rather than thyratron tubes.11)

Diagram of phase control. Top shows the fraction of the pulse used. Bottom shows the point at which the thyratron switches on. Image by Zureks, CC BY-SA 2.5.

The thyratron tubes in the power supply resemble vacuum tubes, but have argon and mercury vapor inside their glass shell (unlike vacuum tubes which not surprisingly contain a vacuum). These thyratron tubes are constructed from three components: the filament, the plate, and the grid. The filament, kind of like a light bulb filament, heats up and gives off electrons. The plate, connected to the top of the tube, receives electrons, allowing current to flow from the filament to the plate. Finally, a control grid between the filament and the plate can block the electron flow. When electrons flow to the plate, the mercury vapor in the tube ionizes, turning on the tube and producing the blue glow you can see below. (In contrast, a regular vacuum tube has a flow of electrons, but nothing to ionize.) The ionized mercury provides a highly conductive path between the filament and the plate, allowing a large (1.5 amp) current to flow. Once the mercury ionizes, the grid no longer has control over the tube and the thyratron remains on until the voltage between the filament and plate drops to zero. At this point, the ionization ceases and the tube shuts off until it is turned on again.

REC-30 Teletype power supply, showing the thyratron tubes with their blue glow and the neon bulb voltage reference glowing orange. The timer/relay is visible in the upper left.

The grid voltage on a thyratron controls the tube. The negative voltage on the grid repels the negatively-charged electrons, preventing electron flow between the filament and the plate. But when the voltage on the plate gets high enough, electrons will overcome the grid repulsion, causing the tube to turn on. The important factor is that the more negative the grid, the more repulsion and the higher the plate voltage needs to be for the tube to turn on. Thus, the grid voltage can control the point in the AC cycle at which the tube turns on.
The control circuit regulates the power supply's output voltage by changing the grid voltage and thus the thyratron timing.9 I used the power supply's adjustment potentiometer to show below how changing the timing changes the voltage. I could set the output voltage (blue) between 114 and 170V. The regulation circuit changed the grid voltage (pink), resulting in the thyratron timing (cyan and yellow) changing accordingly.10 The oscilloscope trace is a bit tricky to interpret; see the footnote for details.12 The main thing to notice is how the ends of the cyan and yellow curves move back as the voltage increases, indicating the thyratrons fire earlier.

Change in phase angle as Teletype REC-30 power supply is adjusted from 130V to 170V output. Yellow and cyan are the voltage across the thyratrons. Pink is the grid control signal. Blue is the (inverted) output voltage.

The schematic below shows the circuitry of the REC-30 power supply (larger schematic here). The AC input circuit is highlighted in green, with the autotransformer adjusting the input voltage to 230V and feeding the drive transformer. These thyratron tubes have the interesting requirement that they must be heated up before use to ensure that the mercury is vaporized; a bimetallic timer waits 20 seconds before powering up the drive transformer.8 On the secondary side of the drive transformer, the 400V drive voltage is in red, the regulated output voltage from the thyratrons is orange, and the low side of the output is blue.13 The regulation circuit (at the bottom) is a bit more complicated. The grid control tube (a 6J6 pentode) provides the control voltage to the grids of the thyratrons, controlling when they will turn on. The grid control tube takes a feedback voltage (pin 5) from the output via a potentiometer voltage divider. The output from this tube (pin 3) sets the thyratron grid voltage to keep the output voltage regulated. The voltage drop across the neon bulb is almost constant, allowing it to act as a voltage reference providing a fixed voltage for the control tube's cathode (pin 8).

Schematic of the REC-30 Teletype power supply. For some reason, the schematic indicates ohms with a lower-case ω rather than the usual upper-case Ω.

Comparison with a MacBook power supply

It's interesting to compare the REC-30 power supply to a modern MacBook power supply, to see how much switching power supplies have improved in 70 years. An Apple MacBook power adapter is roughly comparable to the REC-30 power supply, producing 85 watts of DC power from an AC input (versus 108 watts from the REC-30). However, the MacBook power supply is about 10 ounces, while the REC-30 is over 100 pounds. The MacBook supply is also considerably less than 1% the size of the REC-30 power supply, showing the incredible miniaturization of electronics since the 1940s. The bulky thyratron tubes to switch the power have been replaced by compact MOSFET transistors. The resistors have shrunk from the size of a finger to smaller than a grain of rice. Modern capacitors are smaller, but haven't miniaturized as much as resistors; capacitors are some of the largest components in the MacBook charger, as you can see below.

Inside an Apple MacBook 85W power supply. Despite its small size, the MacBook power supply is much more complex than the REC-30. It contains a Power Factor Correction (PFC) circuit to improve power line efficiency. Multiple safety features (including a 16-bit microcontroller) monitor the power supply, shutting it down if there is a fault.

Most of the weight reduction in the Macbook charger comes from replacing the enormous autotransformer and plate drive transformer with a tiny high-frequency transformer. The MacBook power supply operates at about 1000 times the frequency of the REC-30, which allows the inductors and transformers to be much, much smaller. (I wrote more on the MacBook charger here and more on power supply history here.)
The following table summarizes the differences between the REC-30 power supply and the MacBook power supply.

	REC-30	MacBook 85W
Weight	104.5 lb	0.6 lb
Dimensions	25" x 8" x 11" (1.3 ft^3)	3 1/8" x 3 1/8" x 1 1/8" (0.006 ft^3)
Input AC	95-250V AC, 25-60 Hz	100-240V 50-60Hz
Output	108W: 120V DC at 0.9A	85W: 18.5V DC at 4.6A
Idle (vampire) power consumption	60W	&lt0.1W
Harmful substances inside	Mercury, lead solder, probably asbestos wire insulation	No: RoHS certified
Output control	Bimetallic timer / relay	16-bit MPS430 microcontroller
Switching elements	323 thyratron tubes	11A N-channel power MOSFETs
Voltage reference	GE NE-42 neon glow discharge bulb	TSM103/A bandgap reference
Switching control	6F6 pentode tube	L6599 resonant controller chip
Switching frequency	120 Hz	~500 kHz

I measured the quality of the REC-30's output voltage (below). The power supply provides much higher quality output than I expected, with only about 200 mV of ripple (the waves in the horizontal blue line) which is close to Apple-level quality. There are also narrow spikes (the vertical lines) of about 8 volts when the thyratrons switch. These spikes are fairly large compared to an Apple power supply but still better than a cheap charger.

Output from the REC-30 power supply, showing a small amount of ripple and switching spikes.

Conclusions

The REC-30 power supply provided over 100 watts of DC power for Teletype systems. Introduced in the 1940s, the REC-30 was an early switching power supply that used mercury-filled thyratron tubes for efficiency. It was a monstrously large unit for a 100 watt power supply, weighing over 100 pounds. A comparable modern power supply is under 1% of the size and weight of this unit. Despite its age, the power supply worked flawlessly when we powered it up, as you can see in Marc's video below. The power supply is beautiful in operation, with a blue glow from the thyratrons and orange from the large neon bulb.

I announce my latest blog posts on Twitter, so follow me at @kenshirriff for future articles. I also have an RSS feed. Thanks to Carl Claunch and Marc Verdiell for work on the power supply.

Notes and references

1. For more information on how Teletypes operate, see this page. For comprehensive information, see Fundamentals of Telegraphy (Teletypewriter), Army Technical Manual TM 11-655, 1954. More REC-30 schematics are here and documentation is here. ↩
   
2. In the 1870s, Émile Baudot invented the 5-bit Baudot code. A different 5-bit code was created by Murray in 1901 and standardized as ITA2. Both codes look like the characters are in random order; the original Baudot code used a Gray code, while the Murray code was optimized to use the fewest holes for common characters, reducing wear and tear on the machinery. (It wasn't until ASCII in the 1960s that putting the alphabet in binary order became a thing.) ↩
   
3. Note that in contrast to voltage-based signals, the components of the current loop must form a topological loop for the current to flow. Removing a device will break the circuit unless provisions are made to close the loop. As a result, the Teletype system is full of jacks that short when you unplug a component, to keep the loop intact. ↩
   
4. The main reason the REC-30 power supply is so heavy and bulky compared to modern switching power supplies is that it switches at 60 Hz (and even down to 25 Hz), while modern power supplies switch at tens of kilohertz. Since the transformer's EMF is proportional to the frequency, a high-frequency transformer can be much smaller than the corresponding low-frequency transformer (details). ↩
   
5. Isolation between the AC input and the DC output is a key safety feature in most power supplies, from chargers and PC power supplies to the REC-30, preventing a shock from the DC output. In the REC-30, the plate drive transformer has the critical role of providing isolation. (Note that the autotransformer doesn't provide any isolation protection because it has a single main winding; touching its output is like touching the AC input.) The rest of the circuitry is carefully designed so there is no direct path between the AC input and the output: the control circuitry is all on the secondary side, the filaments are powered by isolated windings off the autotransformer, and the relay provides isolation in the timer. Also note that for safety the 120V DC output is floating, rather than grounding either side; this means you'd need to touch both sides to get a 120V shock. ↩
   
6. The power supply accepts a wide variety of input voltages (95, 105, 115, 125, 190, 210, 230, 250V AC) as well as multiple frequencies: 25, 40, 50, and 60 Hz. While modern switching power supplies can automatically adjust to handle the input voltage, the REC-30 required a wire to be moved to the proper autotransformer tap to support a different voltage. 25 Hertz might seem like a strange frequency for a power supply to support, but many parts of the United States used 25 Hertz power in the 1900s. In particular, Niagara Falls generated 25 Hertz electricity due to the mechanical design of its turbines. In 1919, more than two thirds of power generation in New York was 25 Hertz and it wasn't until as late as 1952 that Buffalo used more 60 Hertz power than 25 Hertz power. Because of the popularity of 25 Hz power, many of IBM's punch card machines from the early 1900s could also operate off 25 Hertz (details). ↩
   
7. Modern switching power supplies use pulse-width modulation (PWM) schemes to switch on and off thousands of times a second. This results in a smaller power supply and gives smoother output than switching once per AC cycle, but requires more complicated control systems. ↩
   
8. In the REC-30 power supply, the 20 second delay before powering up the tubes is accomplished by a timer and relay. The timer uses a bimetallic strip with a heater. When you turn on the power supply, the filaments are powered immediately to heat up the tubes. Meanwhile, a heater inside the timer warms the bimetallic strip; eventually the strip bends enough to close the contacts and energize the tubes. At this point, the relay latches the contacts closed. ↩
   
9. Initially, I assumed that as the load increased, the thyratrons would switch on for longer periods of time to provide more current. However, I did oscilloscope measurements under varying load and found no phase shift. This turns out to be the expected behavior; a transformer provides essentially constant voltage regardless of the load. Thus, the thyratron timing remains essentially the same as the load changes and the transformer just provides more current. You can see the thyratrons brightening as the current increases in this video. ↩
   
10. Under low load, the power supply sometimes skips entire AC cycles, rather than switching the thyratrons mid-cycle. This is visible as the thyratrons start to flicker rather than glow steadily. I'm not sure if this is a bug or a feature. ↩
    
11. The modern solid-state equivalent of the thyratron is the silicon controlled rectifier, also known as the SCR or thyristor (combining "thyratron" and "transistor"). The SCR has four semiconductor layers (rather than a 2-layer diode or 3-layer transistor). Like the thyratron, the SCR is normally off until triggered by the gate input. It then remains on, acting like a diode, until the voltage drops to 0, at which point is switches off. A TRIAC is a semiconductor device similar to a SCR, except it can pass electricity in either direction, making it more convenient for AC use. ↩
    
12. In the oscilloscope trace, the yellow and cyan curves are the voltage across the two thyratrons. The flat part (where the voltage difference is approximately zero) is where the thyratron is firing. The two thyratron tubes are not totally symmetrical for some reason, with the yellow one usually firing later. (This is visible while watching the thyratrons, as one glows more than the other.) The pink line is the grid control voltage. Note that it increases to make the output voltage increase, causing the thyratrons to fire earlier. A vertical spike is visible in the pink line; this is noise as the thyratron fires. The blue line at the bottom is the output voltage (inverted); the line goes down as the voltage increases.
    One puzzle is that there is always one thyratron firing; either the yellow or cyan line is always at 0. I would expect a gap between the zero point of the plate voltages and when the other thyratron fires. My suspicion is the large inductors are pulling the filament negative so even when the plate is negative, there is still a positive voltage between the filament and the plate. ↩
    
13. The filament circuit for the power supply is a bit tricky since the thyratron filaments are used both to heat the tubes and as the cathode. The filaments are provided with 2.5V by the autotransformer. In addition, the filaments act as the cathodes in the thyratrons, so they produce the output voltage and are connected to the high side of the output. To perform these two tasks, the split winding of the autotransformer superimposes the 2.5V filament voltage but passes the output voltage straight through. The two thyratrons use a total of 35 watts just for the filaments, so you can see that filament heating wastes a lot of energy and gives off a lot of heat, somewhat negating the advantages of a switching power supply. ↩
    
14. The introduction of Teletypes for Navy use was described in BuShips Electron, Sept 1945. The development of radio-connected Teletypes (RTTY), typically using frequency-shift keying, allowed the adoption of Teletypes for Navy use. The Navy first used radio Teletypes for communication between shore stations, and then moved to shipboard use. The biggest advantage of a Teletype was it was at least four times as fast as a radio operator transmitting by hand. In addition, paper tape allowed messages to be automatically copied and relayed. Teletypes could also be integrated with cryptographic equipment such as SIGTOT which used a one-time pad. More on Teletypes in World War II here. ↩