Deep dive into how the Teensy microcontroller interacts with the Arduino library

The Arduino language lets you program microcontrollers at a high level, controlling I/O pins without worry about exactly how the microcontroller works. But what's really going on behind the scenes? For my current project, I'm using a Teensy 3.6,1 a development board packaged in a breadboard-compatible 48-pin module that is considerably smaller than a classic Arduino.2 The Teensy uses a fairly powerful microcontroller, a 32-bit ARM processor running at 180 megahertz, and it is (mostly) compatible with the Arduino programming environment. I wanted to understand the low-level hardware better, so I investigated the implementation of one of the Arduino functions. Specifically, this post explains exactly how the analogWrite() function works in the Teensy 3.6. Disclaimer: this blog post goes into excessive detail on an obscure subject, so feel free to stop reading now :-)

An Arduino (top) and Teensy 3.6 (bottom).

analogWrite(): creating a PWM output

The Arduino IDE lets you quickly create an application using functions that abstract away the microcontroller's implementation details. In comparison, if you program a microcontroller directly, its hardware functions are activated by accessing special memory locations that act as control registers. There may be thousands of registers, different for each microcontroller, and described in thousand-page manuals, so programming a microcontroller directly can be daunting.

Using the Arduino library, you can put a voltage on an output pin with the analogWrite(pin, value) function. You specify a value between 0 and 256, where 0 is completely off and 256 is completely on and the library takes care of the details. For instance, analogWrite(pin, 64) produces an output value of 25% (i.e. 64/256). You might expect this would produce an analog voltage at 25% of the maximum, but despite the function's name, the output is not analog. Instead it is a digital pulse-width modulated (PWM) signal, which averages out to the desired value.3 As the oscilloscope trace below shows, the output switches between full-on and full-off, remaining on 25% of the time.4 Even though it doesn't produce a true analog output, the analogWrite function is useful for many tasks, such as controlling LED brightness.

Oscilloscope output showing the output from analogWrite().

The diagram below shows how the output changes with different analogWrite values, from 0 (completely off) to 256 (completely on). The main point is that the output is really digital, with a larger input parameter causing the output to be on for a larger fraction of the time. This technique is called Pulse Width Modulation (PWM), since the width of the pulse changes with the input.

Examples of different analogWrite values, from 0 to 256.

The diagram below illustrates how the microcontroller produces the PWM output. Internally, a timer repeatedly counts from 0 to 255, generating a counter value. Each time the timer starts at 0, the output is set high. When the timer matches the specified value (64 in this case), the output goes low. Thus, the match value controls how long the output remains high in each cycle; the larger the value, the longer the output remains high. The timer increments every 8 microseconds, so the total cycle length is 2048 microseconds, yielding a frequency of 490 Hz.

A PWM output is implemented by a timer and a match value.

The analogWrite function is sufficient for most purposes, but how does it work at the microcontroller register level? The manual for the Teensy's MK66FX1M0 processor explains how the chip's registers work, but is 2237 pages long. (I've extracted the relevant bits and give references to manual sections if you want to know more.) The code for the Teensy implementation of analogWrite is in a file called pins_teensy.c. Because the code supports multiple processors, it is full of #ifdefs; the Teensy 3.6 code is selected by the __MK66FX1M0__ and KINETISK5 defines, specifying the processor type and family. The code contains a bunch of case statements to handle all the different types of PWM pins. I'm using pin 30 in my example, which is defined in that file as FTM2_CH1_PIN (FlexTimer 2 Channel 1 pin). (I'll explain below why this timer is pin 30.)

The code to handle that pin is:

cval = ((uint32_t)val * (uint32_t)(FTM2_MOD + 1)) >> analog_write_res;
FTM2_C1V = cval;
FTM_PINCFG(FTM2_CH1_PIN) = PORT_PCR_MUX(3) | PORT_PCR_DSE | PORT_PCR_SRE;

As you can see, this code is much more complex than the analogWrite() call. In brief, the first line computes the counter value (match value) at which the output should go to 0. The second line stores this value into the timer control register. The third line configures pin 30 for the timer output. Next, I'll explain each of these lines in more detail.

The first line handles the difference between the conceptual timer (counting from 0 to 255) and the physical implementation of the timer, which is 16 bits and counts at a much higher rate. To match the Arduino's PWM frequency (490 Hz), the Teensy timer counts to 61439. This line scales the input value (0 to 256) to the desired range (0 to 61440). Specifically, the hardware register FTM2_MOD (timer 2 modulo) holds 61439, the value that this timer counts to.6 Multiplying the input value by 61440 and dividing by 256 scales the input value to the new range. (The value 8 for analog_write_res indicates 8 bits of count resolution, i.e. 256.)7

The next line of code stores this value into timer 2's Channel 1 Value register FTM_C1V,8 which controls the pulse width. This register holds the "match value"; when the timer counter reaches this value, the output drop to 0.

The third line configures pin 30 for the output from the timer. The FTM_PINCFG macro handles pin configuration, which in this case updates the configuration for pin 30 (CORE_PIN30_CONFIG).11 The PORT_PCR_MUX(3) macro selects the pin's function from the pin multiplexer, which I'll explain in the next section.10 The PORT_PCR_DSE option sets Drive Strength Enable, enabling high-current output. The PORT_PCR_SRE option sets Slew Rate Enable, slowing the pin's slew rate (how fast it changes value).9 These values are combined and stored in the appropriate bit fields of the Pin Control Register, shown below. (The macros ensure that each value goes into the right position.)

This diagram shows how multiple fields are packed into a Pin Control Register. (From Section 12.5.1 of the manual.)

Filling in the macros, the original analogWrite(30, 64) call becomes:

*(uint32_t *)0x400B8018 = 15360;
*(uint32_t *)0x4004A04C = 0x344;

Thus, in the end, the analogWrite call turns into two stores to microcontroller registers.

Determining the pin and its function

Pin configuration is more complex than you might expect. The problem is that the processor chip has 144 pins (in a 12×12 grid), but the microcontroller provides a much larger number of functions. The solution is that each pin has up to 8 different multiplexed functions, and you can select one of these functions for each pin. Thus, you can't use all the features of the chip at the same time, but hopefully you can use the features you need.

The chip has a 12×12 grid of solder balls on the bottom. (Photo from Digi-Key.)

In the example I'm using GPIO pin 30, but this pin number is part of the Arduino API: the microcontroller has no pin 30. So how does pin 30 get a meaning? In this section, I explain how pin 30 maps onto a physical pin of the microcontroller (pin D11 in this case) associated with a PWM timer (FlexTimer 2 channel 1 in this case).

The function of each Teensy pin is documented, but I wanted to figure out "from scratch" what GPIO pin 30 means. Looking at the schematic shows the Teensy's pin 30 is connected to pin D11 of the processor, which is labeled "PTB19". (Processor pins are labeled with a letter and number corresponding to the pin's grid position.)

Detail of the Teensy 3.6 schematic showing microcontroller pin D11 is connected to Teensy GPIO pin 30.

Chapter 11 of the manual lists the names and functions for each pin (excerpted below). As mentioned earlier, each physical pin supports multiple functions. Pin D11 has the official name "PTB19" and has seven different functions assigned to it: Touch Screen, GPIO PorT B, CAN bus, FlexTiMer FTM2_CH1 (that we're using), I2S audio, FlexBus, and FlexTiMer 2 Quadrature Decoder.

This excerpt from the manual shows the functions that can be assigned to pin D11.

Each pin has a multiplexer (MUX) that selects which function is assigned to the pin. In order to use the timer with pin D11, the pin configuration register (PCR) for D11 must be configured to assign function 3 to this pin. This was done with the macro discussed earlier, PORT_PCR_MUX(3). Thus, when an analogWrite is performed, the pin is configured to use the appropriate timer.

Initialization

Another piece necessary to make this work is the Teensy's initialization code. The main routine in main.cpp calls _init_Teensyduino_internal_(), which performs the necessary register initialization. The timer 2 initialization code is

FTM2_CNT = 0;
FTM2_MOD = DEFAULT_FTM_MOD;
FTM2_C0SC = 0x28;
FTM2_C1SC = 0x28;
FTM2_SC = FTM_SC_CLKS(1) | FTM_SC_PS(DEFAULT_FTM_PRESCALE);

This sets the initial counter value to 0 and sets the modulo value (maximum count) to 61439 as discussed earlier. The FTM2_C0SC and FTM2_C1SC lines enable PWM mode. The FTM2_SC line sets up the timer clock.12

The last piece is how the code knows the processor type. To support multiple processor types, the files are full of #ifdefs, but where do these get defined? The answer is that the board type and CPU speed are set in the Arduino IDE. The IDE uses these settings to generate flags that are passed to the compiler when compiling the code. The relevant lines for the Teensy 3.6 are in the file hardware/teensy/avr/boards.txt:

teensy36.build.flags.defs=-D__MK66FX1M0__ -DTEENSYDUINO=153
teensy36.menu.speed.180.build.fcpu=180000000

Conclusion

At this point we've reached the foundation. To summarize, the board that you select in the Arduino IDE causes various flags to be passed to the C++ compiler. These flags, in turn, select numerous definitions of registers for that processor, along with the appropriate code. The result is that a function call such as analogWrite(30), acting on an abstract pin 30, gets converted to operations on special microcontroller registers, causing the microcontroller's circuitry to output the desired signal.

It may seem like magic that high-level operations end up doing the right thing across a wide range of microcontrollers, but this is one of the key accomplishments of the Arduino ecosystem. If you really need to know what's going on, I've shown how these abstractions can be unwrapped. But for the most part, the complexity underneath can fortunately be ignored.

I announce my latest blog posts on Twitter, so follow me @kenshirriff. I also have an RSS feed. I wrote about Arduino PWM and its registers in detail here if you want to know more about PWM. Thanks to Paul Stoffregen for answering my questions about Teensy.

Notes and references

1. Why am I using a Teensy 3.6 instead of a newer model? Because the more recent Teensy 4.1 was out of stock. ↩

2. There are also Arduino models in the DIP form factor, such as the Arduino Nano and Arduino Micro. Arduino also has high-power models such as the 32-bit ARM-based Arduino Portenta. ↩

3. The Teensy 3.6 has two digital-to-analog converter (DAC) outputs. For those two pins, the analogWrite() function produces a genuine analog voltage, not a PWM output. ↩

4. The PWM output has a period of 2048 µs, yielding a frequency of about 490 Hertz. The output is controlled in units of 8 µs, so an input value of 1 yields a pulse width of 8 µs, an input of 64 yields a pulse width of 512 µs and so forth. ↩

5. I tried to sort out what "Kinetis" means. NXP has many different microcontrollers and Kinetis is their family of 32-bit mixed-signal ARM Cortex microcontrollers, introduced in 2010. The Kinetis family includes the high-performance K series and the low-power L series. The Teensy 3.x boards use the Kinetis K series and have the preprocessor variable KINETISK defined, while the Teensy LC board uses a Kinetis L processor and has KINETISL defined. ↩

6. The variable FTM2_MOD is defined as the address (400B8008) of the FTM2 modulo register in kinetis.h. Why is the modulo set to 61439? The goal is to make the PWM period match the Arduino's 2048 µs period (approximately 490 Hertz). To see how this happens, start with the Teensy's clock frequency (F_CPU) of 180 MHz. kinetis.h sets the bus frequency F_BUS to 60 MHz based on this. Then pins_teensy.c uses this for the timer frequency F_TIMER. For a frequency of 60 MHz, pins_teensy.c sets DEFAULT_FTM_MOD to 61439 and DEFAULT_FTM_PRESCALE to 1. This prescale value causes the timer to divide its input frequency by 2, so the timer runs at 30 megahertz. At this frequency, 61440 ticks will take 2048 µs as desired.

   Figuring out the address for FTM_MOD2 is more confusing than I expected. If you look at the memory map in the manual (Section 45.4.2), the address for FTM2_MOD is 4003A008 (Peripheral bridge 0), but the Teensy uses address 400B8008 (Peripheral bridge 1, Table 5-3), see kinetis.h. It turns out that the chip has two paths for accessing peripherals: AIPS0 and AIPS1. The timer can be accessed through both paths, but with different register addresses.

   Another confusing thing is that if you try to access FTM2_MOD through the first address, the Teensy will crash. The reason is that the microcontroller lets you conserver power by turning off the clock to each module, a function called "clock gating". If you try to access a peripheral when the clock is disabled, the system terminates with an error. The two different paths to the timer are controlled by separate clocks. Specifically, access through AIPS0 is enabled through System Clock Gating Control Register 6 (SIM_SCGC6, section 13.2.16), while access through AIPS1 is enabled through SIM_SCGC3 (sections 13.2.13). The Teensy startup code enables timer FTM2 through clock gating register SIM_SCGC3 (for AIPS1) but not SIM_SCGC6 (for AIPS0). Thus, accessing the timer through AIPS1 works, but accessing it through AIPS0 crashes. This thread has more information. ↩

7. By default, the value to analogWrite() can range from 0 to 256, i.e. 8 bits of resolution. However, the resolution can be changed by calling analogWriteResolution. Higher resolution gives finer-grain control over the PWM width.

   The Teensy extensions to Arduino include a function analogWriteFrequency(), which provides a more convenient way of modifying the PWM frequency. ↩

8. The Register Descriptions section (45.4.2) describes the memory address for each register. FTM2_C1V is the "Channel Value" at address 4003A018. Section 45.4.7 explains that this register holds the 16-bit counter value that the timer matches against. ↩

9. On my breadboard, a signal has a rise time of 7.5 nanoseconds with slew rate disabled and 15 nanoseconds with slew rate enabled. The fast signal has a bunch of ringing, while the slower signal rises smoothly. ↩

10. The Pin Control Register is described in section 12.5.1 with details in chapter 11, Signal Multiplexing and Signal Descriptions. ↩

11. The macro FTM_PINCFG(FTM2_CH1_PIN) turns into CORE_PIN30_CONFIG, the appropriate configuration register. This is defined in core_pins.h as PORTB_PCR19. The manual (section 12.5) specifies that PORTB_PCR19 (Port B Pin Control Register 19) has address 4004A04C. ↩

12. Register constants FTM2_C0SC and FTM2_C1SC are set to 0x400B800C and 0x400B8014 respectively in kinetis.h. The manual defines these addresses (section 45.4.2) as 4003_A00C and 4003_A014. (The differences are because the timer can be accessed through a different path (Peripheral Bridge 1) at address 400B_8xxx.) These registers are Channel 0/1 Status and Control, discussed in manual section 45.4.6. Each register has 7 bit fields that control the timer function. The initialization value 0x28 selects Edge-Aligned PWM with high-true pulses.

    Register constant FTM2_SC (timer 2 Status and Control) has address 400B8000 in the code and 4003A000 in the manual. Its fields are described in manual section 45.4.3. FTM_SC_CLKS(1) sets the CLKS field to use the system clock as the timer input. FTM_SC_PS sets the prescale to divide the clock by 2, as discussed earlier. ↩

Inside a transistorized shift register box, built in 1965 for Apollo testing

One of the under-appreciated aspects of the Apollo launches to the Moon is how much testing was required. I recently came across an item that was part of this testing: the Computer Buffer Unit. It is essentially a 16-bit shift register that interfaced test equipment to the Apollo Guidance Computer. While a shift register is a trivial circuit nowadays, back then it took a box full of transistors that weighed about 5 pounds. In this blog post, I look inside this unit, describe its unusual packaging and circuitry, and explain how it works.

The Computer Buffer Unit is a 4"×6"×6" box. The three electrical connectors on the left are covered by protective covers. It has a humidity indicator and pressurization valve at the bottom.

Testing for the Apollo missions

The Apollo spacecraft required extensive testing even while it was sitting on the launch pad. Thousands of different spacecraft components needed to be activated and analyzed for various tests. Since the control room was miles away from the launch pad, it wasn't practical to run separate wires to each component. Instead, NASA invented (and patented) a complex digital test system that communicated efficiently between the control room and the rocket. This test system sent digital commands to the launch site, where racks of control and interface units were wired to the spacecraft components. These units decoded the commands and performed the specified operation. Massive quantities of measurement data from the spacecraft were encoded digitally and serialized for communication back to the control room.

The complexity of testing is illustrated by the control room below.2 This is not Mission Control, but a separate control room specifically for testing, called ACE-S/C (Acceptance Checkout Equipment-Spacecraft). These consoles were crammed with control switches, tape readers, CRT displays, chart recorders, and status panels for conducting tests and recording results. The ACE-S/C system supported manual, semiautomatic, and automatic testing, driven by two minicomputers1.

ACE control room. From Applicability of Apollo Checkout Equipment.

All parts of the spacecraft were tested, including the fuel cells, cryogenic fuel storage, communications, and environmental control. For this blog post, the relevant subsystem is "Guidance and Navigation", responsible for determining the Apollo spacecraft's position in space using inertial navigation and guiding it on the proper trajectory including the landing on the Moon's surface. The key to Guidance and Navigation was the Apollo Guidance Computer, 70-pound computers onboard the Lunar Module and the Command Module.

The Apollo Guidance Computer that we restored, next to a replica DSKY.

In space, astronauts operated the Apollo Guidance Computer through the Display/Keyboard (DSKY), a box (above) with keys, indicator lights, and numeric displays. But for ground testing, there needed to be a way to feed commands into the Apollo Guidance Computer from the testing system. The solution was the Computer Buffer Unit, the box that I'm examining. To operate the Apollo Guidance Computer remotely, the ACE test system encoded each DSKY keypress as a 16-bit command3 and sent it to the Buffer Unit. The Buffer Unit converted the message to serial, transferring one bit at a time to the Apollo Guidance Computer, which then processed the desired keypress.4 Thus, the Apollo Guidance Computer could be controlled remotely for testing, providing control over the Guidance and Navigation system, and the Computer Buffer Unit was the interface with the Apollo Guidance Computer.

Inside the Computer Buffer Unit

Next, I'll discuss the physical construction of the Computer Buffer Unit. Removing the lid reveals the components inside.5 The main circuitry consists of six horizontal circuit boards wired into a vertical backplane board; the top board is visible below. One unusual feature is the bag of desiccant inside the unit, zip-tied to the right side of the case. The designers of the unit were worried about Florida humidity and the risk of corrosion.6 To guard against damp air, the unit has a valve on the front so it can be pressurized with dry nitrogen. On the front of the unit, you can see a humidity sensor that changes color to indicate 10%, 20%, and 30% humidity. If the internal humidity exceeded 30%, the desiccant needed to be replaced, as described by the warning label.

The Buffer Unit with the lid removed.

I removed the circuit boards with some difficulty, as they fit tightly. The photo below shows the stack of six printed circuit boards wired into the vertical backplane. The wires from the connectors are soldered directly to the backplane.

With the circuit boards pulled out of the unit, the wiring to the backplane is visible.

The circuit boards can be opened up like a book to provide access to the inner boards. The boards are not soldered directly to the backplane, but are connected by short, flexible wires, allowing them to swing apart. To prevent short circuits between the boards, they are separated by white sheets of (probably) silicone.

After removing six screws, the boards can be unfolded like a book.

The circuitry is constructed in a very unusual way that I haven't seen before. Instead of mounting components directly on the circuit boards, components are mounted on small boards, each forming a module with a logic gate or two. These smaller modules are then soldered on pins above the main circuit boards, forming two-layer boards. Essentially they built pseudo-integrated-circuits on small boards, and then constructed the circuitry from these modules.

Closeup of logic modules mounted on the circuit board. A blue resistor is visible on the underside of the module.

It is difficult to see the components sandwiched between the main board and the smaller modules, but the side view below shows some of the components. The two boards are connected by the vertical pins. A tiny glass diode is visible towards the left. The longer components are resistors. The shiny metal-can transistors are in the middle of the module and harder to see.

This side view shows a latch module (bottom) attached to the circuit board (top). The diodes, resistors, and transistors of the latch module are visible.

One question is why the circuitry is implemented with small circuit boards attached to the larger circuit board, instead of mounting the components directly on the circuit board. This approach seems overly complex and makes the boards twice as thick. One advantage, though, is that the separate logic modules could be manufactured, testing, and repaired separately, important in an era when semiconductors were less reliable. Second, the main boards and the logic modules are different types of printed circuit boards: four-layer circuit boards with widely-spaced traces versus single-sided but dense boards.

Logic gates

The circuitry is implemented with a logic family called Diode-Transistor Logic (DTL). This type of logic was used in the early 1960s as it only required one (expensive) transistor per gate, using cheaper diodes where possible. As transistor prices dropped, Transistor-Transistor Logic (TTL) became more popular because of its better performance. Nowadays fast, low-power CMOS logic is used in most integrated circuits.

I reverse-engineered the schematic below, which shows a NOR gate from this unit. This gate has two inputs, as well as two outputs (for reasons that will be explained below). If both inputs are low (0), the transistor will be turned off. As a result, the resistors pull the outputs high, producing 1 outputs.

The NOR gate with both inputs low, outputs high.

If an input is high, the circuit behaves as shown below. Current flows from the input pull-up resistor through the diodes and the transistor's base, turning the transistor on. As a result, current flows from the outputs, through the transistor to ground, pulling the outputs low. Thus, the circuit implements a NOR gate: the output is 1 if all inputs are low, and 0 otherwise.

The NOR gate with a high input, outputs high.

The reason for multiple outputs is clever. If you connect the outputs from multiple gates together, this combined output will be pulled low if any output is low (i.e. the transistor is turned on), and otherwise will be pulled high by the resistor.7 This logic is equivalent to an AND gate. Note that the AND gate is implemented "for free" by wiring outputs together, without requiring additional logic; this is called wired-AND. However, you can't use a gate's output in two different wired-AND gates, since everything will be shorted together. Instead, a gate provides multiple outputs that can be wired independently; the diodes keep the outputs isolated from each other.

The board I examined has 5 different types of logic module8, from an inverter with 1 input and 8 outputs to a module with two 2-input, 5-output NOR gates. These modules follow the circuit above, but with different numbers of inputs and outputs.

Implementation of the shift register

The idea behind a shift register is to store multiple bits in a row. Each time a clock signal is activated, the bits are shifted by one position. Shift registers can be used to store data, convert parallel data to serial, or convert serial data to parallel. In this Buffer Unit, the shift register converted a 16-bit parallel value from the test equipment into a serial stream of bits for the Apollo Guidance Computer.9

The board implements four bits of the 16-bit shift register. The schematic below shows the circuitry for a one-bit stage of the shift register. There's a lot going on, but I'll try to explain it. The heart of the stage consists of two latches, which store one bit. A bit is stored by first updating the primary latch, and then the secondary latch. (Each latch consists of two cross-coupled NOR gates, and can hold either a 0 or a 1.) The shift out lines are the outputs from the shift register stage, a regular output and an inverted output.

One stage of the shift register. It can read the bits in parallel, or shift a bit from one stage to the next.

Each shift out line is fed to the shift in lines of the next stage, allowing the bits to be transferred from stage to stage through the shift register. The shift and load control lines, along with the AND gates, select the input to each stage. With shift high, the input will be the shift out from the previous stage. With load high, the input reads the external bit in lines. This allows a 16-bit data word to be read into the shift register in parallel. (I'm not sure what the clear bit function is used for.) After a bit has been loaded into the primary latch, the clock line is activated to load the bit into the secondary latch, completing the shift or load cycle.

An interesting function of the unit is that after loading, the value in the latch is compared to the input value, to make sure that the circuit is operating correctly. If there is a mismatch, a compare AND gate will activate, clearing the match line. (A compare AND gate will activate if the input bit is 1 and the latch bit is 0, or vice versa.) This circuit also detects a fault in the bit input wires. Each bit is provided over two wires: one with the bit value and one with the inverted bit value. If a wire is broken or affected by noise, the comparison will fail.10

This diagram shows the functions of the gates. Note that the circular golden transistors are faintly visible through the circuit boards.

The board above11 contains four of these shift-register stages. The photo above shows how these stages map onto the hardware. The external signals (4 pairs of bit lines) enter at the bottom of the board, and pass through the input inverters. The 8 primary latch NOR gates implement four primary latches. Four secondary latch modules implement the four secondary latches, since each module contains two NOR gates. The clock driver, load driver, and shift driver provide 8 copies of the clock, load, and shift signals for the circuitry. Finally, the two match NOR gates combine the 8 match signals. (Note that since the AND gates are implemented with wired-AND, they don't use additional circuitry and do not appear in this diagram.)

I/O and power

I'll wrap up with a few comments on the I/O and power supply for the Buffer Unit. The unit has three military-style connectors on the front. At the top is a 61-pin connector for receiving the parallel data and control signals from ground equipment. (The pin count is larger than you might expect because each bit uses two wires as discussed earlier. Also, many of the 61 pins are unused.)

The unit has three connectors. The unit receives parallel data from ground equipment through the 61-pin connector at the top. The middle connector communicates the serial data to the Apollo Guidance Computer. The unit is powered with 28 volts through the bottom connector, which has larger pins for the high-current supply.

The middle connector has four pins that provide the serial data stream to the Apollo Guidance Computer. The wiring is a bit unusual. Instead of transmitting data over one serial line, the unit uses two pairs of lines: one to transmit "0" bits and one to transmit "1" bits. To provide electrical isolation between the unit and the Apollo Guidance Computer, these signals are transmitted via two small pulse transformers, shown below. When a pulse is fed into a pulse transformer, a similar pulse is produced on the output. (In modern equipment, an optoisolator provides similar functionality.)

Two pulse transformers on the top circuit board. Each small transformer is about 1 cm in diameter.

The bottom connector on the unit has two thick pins to provide 28 volts to the unit. This view inside the unit shows the power converter, a sealed black box. I believe this is a switching power supply module that converted the 28-volt input into the lower voltage required by the logic circuitry. It also provided electrical isolation from the power supply. The smaller black box on the right is an EMI filter on the power input; the Apollo ground test equipment encountered faults from voltage transients and electrical noise, so they added filtering.

The power supply components are sealed in black plastic.

Conclusion

This Computer Buffer Unit was built in 1965, a time when the industry was shifting from transistors to integrated circuits. This may explain the Unit's unusual construction technique, small circuit-board modules that are like integrated circuits built from discrete components.12 Interestingly, Motorola built a similar Buffer Unit for NASA that used integrated circuits (but was just as large),13 illustrating that transistors and integrated circuits were both viable approaches in 1965.

This box also illustrates the rapid pace of integrated circuit technology since the 1960s. The first commercial MOS integrated circuit was a 20-bit shift register introduced in 1964 and by 1970, Intel was producing a 512-bit shift register. In 1971, Western Digital was selling a UART chip, putting a complete parallel-to-serial and serial-to-parallel communication system onto a chip. Thus, it took 6 years to shrink the complex shift-register box down to a single chip (more or less). Nowadays, this functionality forms a tiny part of a complex chip. Coincidentally, Moore's Law, describing the exponential growth of integrated circuits, was published in 1965, the same year this box was manufactured.

I announce my latest blog posts on Twitter, so follow me @kenshirriff. (The Twitter thread corresponding to this blog post is here.) I also have an RSS feed. Thanks to Steve Jurvetson for letting me examine this artifact. A video tour of his space museum is here. Thanks to Mike Stewart for providing documents and extensive information on this box.

Notes and references

1. The photo below shows the ACE computer room that supported ACE testing. The system was controlled by two 13-bit CDC 160-G minicomputers. Strangely, the CDC 160-G minicomputers were 13-bit computers, with 13-bit addresses, 13-bit registers, and 13-bit arithmetic. The earlier CDC 160 computer was 12 bits, and CDC improved the 160-G model by adding one more bit. The CDC 160 was designed by Seymour Cray, reportedly over a weekend.

   

   "An ACE Station with twin Control Data computers." From Computers in Spaceflight.

    ↩

2. There were about 10 ACE installations for testing at various sites. ACE testing was performed at contractor sites, as well as at the launch pad. ↩

3. To send a DSKY keypress through the testing system, each keypress was encoded as 5 bits as shown below. The 16-bit message consisted of a 1 bit followed by three copies of the 5-bit keypress, with the middle copy inverted. (Sending the keypress in triplicate detected communication errors.)

   

   The encoding of keys when communicating with the Apollo Guidance Computer. From ACE-S/C Operator's Manual.

    ↩

4. The serial protocol used by the Apollo Guidance Computer is a bit unusual compared to modern serial protocols. Instead of a single serial line, it used two pairs of wires: one to receive a 1 bit and one to receive a 0 bit. This worked well with the Apollo Guidance Computer hardware, which included a feature for incrementing and decrementing counters in response to interrupts. In particular, a serial input 0 triggers a SHINC instruction (shift left), while a serial input 1 triggers a SHANC (shift and increment by 1) instruction.

   (The interrupt-triggered counter mechanism worked well except during the Apollo 11 landing, when the power supply for the Apollo Guidance Computer and the power supply for the rendezvous radar had a phase difference. For complex reasons, this resulted in a high rate of interrupts, overloading the Apollo Guidance Computer and causing restarts. This was indicated by the famous 1201 and 1202 program alarms during the landing.)

   

   The K-START (Keyboard - Selections To Actuate Random Testing) panel is used to send commands to the Apollo Guidance Computer. From ACE-S/C Operator's Manual.

   In the ACE testing control room, DSKY keypresses were entered on a panel called K-START (Keyboard - Selections To Actuate Random Testing), shown above. The keyboard corresponds to the keyboard on the DSKY, while it has other switches specific to testing. These key entries could also be recorded on perforated tape and played back at high speed. ↩

5. Another interesting feature of the unit is how it is mounted on a rack. The back of the unit has two Teflon-lined holes. Two "dagger pins" from the rack fit into these holes. On the front, the unit has two small hold-down hooks; a knob on the rack engages with the hook to hold the unit in place. The mounting hooks are type NAS 622, an aerospace standard. The hold-down mechanism is described here.

   

   Back of the Buffer Unit with identifying label and two holes for dagger pins. The labels say "Unit, Computer Buffer Guidance & Navigation. NAA/S & ID Control No. ME901-0271-0002. Stock No. Contract No. M5H3XA-450001. NAA/S & ID Inspection Serial No. Control Data Corporation MFGR Part No. 106068-0002. Mfgr Serial No. 10136SA08185. US Nov 19 1965.

    ↩

6. The document Acceptance Checkout Equipment for the Apollo Spacecraft discusses the corrosion problems encountered by the test equipment due to humidity and insufficient air conditioning. The specifications don't discuss pressurization of the unit, but I'm assuming they used nitrogen based on other items I've studied. ↩

7. One subtlety with the wired-AND gate is that connecting multiple outputs together will result in multiple pull-up resistors in parallel, which may provide too much pull-up current. The solution is that some gates have outputs without pull-up resistors, so each wired-AND output has a single pull-up. The wired-AND isn't entirely free, since the multiple outputs require multiple diodes, but diodes are inexpensive compared to transistors. I should admit that I'm not 100% sure of the circuitry. Since the components are all hidden underneath the module, I had to deduce the circuitry by probing it from above. There were a few inputs that didn't seem to have connectivity; perhaps there are capacitors to make these inputs pulse-based. ↩

8. The board I examined uses the following types of modules:
   2304: 1-in, 8-out inverter
   2309: 3-in, 4 out NOR
   2311: 4-in, 2-out NOR
   2319: 1-in, 4-out inverter
   2314: dual 2-in, 5-out NOR (larger than the other modules) ↩

9. The specifications for the Buffer Unit describe its purpose: "This specification covers the requirements for a Guidance and Navigation Computer Buffer Unit, hereinafter referred to as the G&N buffer. The G&N buffer shall form a part of the Digital Test Command System (DTCS) which is the up-link portion of the Automatic Checkout Equipment (ACE). The ACE will be used as ground support equipment for the Apollo space craft. The G&N buffer shall receive remotely generated digital test commands from the control room via the DTCS and shall store, verify, and shift out G&N data in appropriate format to the G&N on-board computer."

   

   Functional diagram of the Buffer Unit. Image from Specification MC 901-0666 courtesy of Mike Stewart.

   The specifications for the Computer Buffer Unit can be viewed online: MC901-0666, ME901-0666, ME901-0271, ME476-0070.

   The unit includes more functionality than just a shift register (but not much more). As shown in the functional diagram above, the unit also includes the clock oscillator that controls the timing of the serial pulses. Second, it contains a control circuit to handle loading the bits in parallel and then shifting them out serially. Third, for reliability reasons, it has a comparator circuit to check that the bits loaded into the shift register match the input bits. ↩

10. Modern systems often use differential signaling, using two complementary signals for a bit. Looking at the difference between the two signals provides noise immunity, since electrical noise will often affect both signals equally, and thus will be canceled out. Although the Buffer Unit uses two complementary signals, it doesn't provide this noise immunity, since the two signals are processed independently rather than differentially. ↩

11. I only reverse-engineered one of the boards, since I didn't want to risk more disassembly, and one board is enough to understand the basic logic. I studied board 6 of the unit, which implements bits 15 through 18 of the shift register. Board 3 implements bits 3-6, board 4 implements bits 7-10, as well as mode bits 1 and 2, board 5 implements bits 11 through 14, and board 6 (the one I examined) implements bits 15 through 18. Boards 2 and 4 implement control logic, while board 1 has the output driver transformers.

    

    With board 6 folded down, board 5 is visible.

    The photo above shows board 5. Note that the circuit layout is entirely different from board 6. I thought that the unit might consist of four identical 4-bit shift register boards, but it turns out that the boards are optimized for particular roles. ↩

12. In the context of "not-quite-integrated circuits", I should mention IBM's use of hybrid modules (called SLT) for the System/360 mainframes. These small aluminum-cased modules contained a few transistor or diodes as silicon dies, mounted on a ceramic substrate along with thick-film resistors. These modules were not quite integrated circuits, since they were built from discrete (but unpackaged) components. But they were closer to integrated circuits than the modules in the Buffer Unit, which used packaged transistors, resistors, and diodes on a printed circuit board. ↩

13. Motorola made a similar Buffer Unit, but they used integrated circuits, specifically Motorola's line of high-speed ECL chips, introduced in 1962. Since each chip is a few gates, it still took multiple boards to build the unit. Apollo Guidance Computer expert Mike Stewart has photos of the Motorola box here, as well as reverse-engineered schematics. The functionality of the Motorola box is nearly identical, except it has separate inputs for the 16-bit compare value. It is built with chips such as the MC308 flip flop and MC 309 dual NOR gate, described here.

    

    A board from the Motorola version of the Buffer Unit. Each metal can is an integrated circuit. Photo courtesy of Mike Stewart.

     ↩

Teardown of a PC power supply

Have you ever wondered what's inside your computer's power supply? The task of a PC power supply is to convert the power from the wall (120 or 240 volts AC) into stable power at the DC voltages that the computer requires. The power supply must be compact and low-cost while transforming the power efficiently and safely. To achieve these goals, power supplies use a variety of techniques and are more complex inside than you might expect. In this blog post, I tear down a PC power supply and explain how it works.1

The power supply I examined, like most modern power supplies uses a design known as a "switching power supply." Switching power supplies are now very cheap, but this wasn't always the case. In the 1950s, switching power supplies were complex and expensive, used in aerospace and satellite applications that needed small, lightweight power supplies. By the early 1970s, though, new high-voltage transistors and other technology improvements made switching power supplies much cheaper and they became widely used in computers. Now, you can buy a phone charger for a few dollars that contains a switching power supply.

The ATX power supply that I examined was packaged in a metal box the size of a brick, with a remarkable number of colorful cables emerging from it. Removing the case reveals the components below, tightly packed to keep the power supply compact. Many of the components are hidden by the heat sinks that keep the power semiconductors cool along with the fan at the right.

The power supply, removed from the case. The large bundle of wires at the left is connected to the computer. The large component in the middle that looks like a transformer is a filter inductor. Click this photo (or any other) for a larger version.

I'll start with a quick overview of how the switching power supply works, and then describe the components in detail. Starting at the right, the power supply receives AC power. The input AC is converted to high-voltage DC, with the help of some large filtering components. This DC is switched on and off thousands of times a second to produce pulses that are fed into a transformer, which converts the high-voltage pulses into low-voltage, high-current pulses. These pulses are converted to DC and filtered to provide nice, clean power, which is fed to the computer's motherboard and disk drives through the bundle of wires on the left.

While this process may seem excessively complex, most consumer electronics, from your cell phone to your television, use a switching power supply. The high frequencies allow the use of a small, lightweight transformer. In addition, switching power supplies are very efficient; the pulses are adjusted to supply just the power needed, rather than turning excess power into waste heat as in a "linear" power supply.

Input filtering

The first step is for the input AC to go through an input filter circuit that blocks electrical noise from exiting the power supply. The filter below consists of inductors (the toroidal coils) and capacitors. These boxy gray capacitors are special Class-X capacitors, designed to be connected safely across the AC lines.

The input filter components

Rectification: converting AC to DC

The 60-Hertz AC (alternating current) from the wall oscillates 60 times a second, but the power supply needs steady DC (direct current) that flows in one direction. The full-bridge rectifier below converts the AC to DC. The rectifier below is marked with "-" and "+" for the DC outputs, while the two center pins are the AC input. Internally the rectifier contains four diodes. A diode allows current to pass in one direction and blocks it in the other direction, so the result is that the alternating current is converted to direct current, flowing in the desired direction.

The bridge rectifier is labeled "GBU606". Filter circuitry is to its left. To the right, the large black cylinder is one of the voltage-doubler capacitors. The small yellow capacitor is a special Y capacitor, designed for safety.

The diagram below shows how the bridge rectifier works. In the first schematic, the AC input has the upper side positive. The diodes pass the voltage through to the DC output. In the second schematic, the AC input has reversed direction. However, the configuration of the diodes ensures that the DC output voltage stays the same (positive on top). The capacitors smooth out the output.

The two schematics show the flow of current as the AC input oscillates. The diodes force current to flow in the direction indicated by their arrow shape.

Modern power supplies accept a "universal" input voltage of 85 to 264 volts AC, so they are usable in different countries regardless of the country's voltage. However, the circuitry of this older power supply couldn't handle such a wide input range. Instead, you had to flip a switch (below) to select between 115 V and 230 V.

The 115/230 V switch.

The voltage selection switch used a clever circuit, a voltage doubler. The idea is that with the switch closed (for 115 volts), the AC input bypasses the bottom two diodes in the bridge rectifier and is instead connected directly to the two capacitors. When the AC input is positive on top, the top capacitor is charged with the full voltage. And when the AC input is positive on the bottom, the lower capacitor is charged with the full voltage. Since the DC output is across both capacitors, the DC output has double the voltage. The point of this is that the rest of the power supply receives the same voltage, whether the input is 115 volts or 230 volts, simplifying its design. The downsides of the voltage doubler are that the user must put the switch in the correct position (or risk destroying the power supply), and the power supply requires two large capacitors. For these reasons, the voltage doubler has gone out of style in more recent power supplies.

The voltage doubler circuit. Each capacitor is charged with the full voltage, so the DC output has double the voltage. The grayed-out diodes are not used when the doubler is active.

Primary and secondary

For safety, the high-voltage components and the low-voltage components are separated, both mechanically and electrically. The primary side below contains all the circuitry that is connected to the AC line. The secondary side contains the low-voltage circuitry. The primary and secondary are separated by an "isolation boundary" (shown in green), with no electrical connections across the boundary. The transformers pass power across this boundary through magnetic fields, without a direct electrical connection. Feedback signals are sent from the secondary to the primary by opto-isolators, which transmit signals optically. This separation is a key factor in safe power supply design: a direct electrical connection between the AC line and the output would create a high danger of electric shock.

The power supply with main features labeled. The heat sinks, capacitors, control board, and output wires have been removed to give a better view. (SB indicates the standby supply.)

Pulses to the transformer

At this point, the input AC has been converted to high-voltage DC, about 320 volts.2 The DC is chopped into pulses by the switching transistor above, a power MOSFET.3 Because this transistor gets hot during use, it was mounted on a large heat sink. These pulses are fed into the main transformer above, which in a sense is the heart of the power supply.

The transformer consists of multiple coils of wire wound around a magnetizable core. The high-voltage pulses into the transformer's primary winding produce a magnetic field. The core directs this magnetic field to the other, secondary windings, producing voltages in these windings. This is how the power supply safely produces its output voltages: there is no electrical connection between the two sides of the transformer, just a connection by the magnetic field. The other important aspect of the transformer is that the primary winding has the wire wrapped around the core a large number of times, while the secondary windings are wrapped around a much smaller number of times. The result is a step-down transformer: the output voltage is much smaller than the input, but at a much higher current.

The switching transistor3 is controlled by an integrated circuit, a "UC3842B current mode PWM controller". This chip can be considered the brains of the power supply. It generates pulses at the high frequency of 250 kilohertz. The width of each pulse is adjusted to provide the necessary output voltage: if the voltage starts to drop, the chip produces wider pulses to pass more power through the transformer.4

The secondary side

Now we can look at the secondary side of the power supply, which receives the low-voltage outputs from the transformer. The secondary circuitry produces the four output voltages: 5 volts, 12 volts, -12 volts, and 3.3 volts. Each output voltage has a separate transformer winding and a separate circuit to produce that voltage. Power diodes (below) convert the outputs from the transformer to DC, and then inductors and capacitors filter the output to keep it smooth. The power supply must regulate the output voltages to keep them at the proper level even as the load increases or decreases. Interestingly, the power supply uses several different regulation techniques.

Closeup of the output diodes. At the left are cylindrical diodes mounted vertically. In the middle are pairs of rectangular power Schottky diodes; each package holds two diodes. These diodes were attached to a heat sink for cooling. At right note the two staple-shaped copper wires used as current-sensing resistors.

The main outputs are the 5-volt and 12-volt outputs. These are regulated together by the controller chip on the primary side. If the voltage is too low, the controller chip increases the width of the pulses, passing more power through the transformer and causing the voltage on the secondary side to increase. And if the voltage is too high, the chip decreases the pulse width. (The same feedback circuit controls both the 5-volt and 12-volt output, so the load on one output can affect the voltage on the other. Better power supplies regulate the two outputs separately.5)

Underside of the power supply, showing the printed circuit board traces. Note that wide separation between the secondary-side traces on the left and the primary-side traces on the right. Also note the wide metal traces used for the high-current supply and the thin traces for control circuitry.

You might wonder how the controller chip on the primary side receives feedback about the voltage levels on the secondary side, since there is no electrical connection between the two sides. (In the photo above, you can see the wide gap separating the two sides.) The trick is a clever chip called the opto-isolator. Internally, one side of the chip contains an infra-red LED. The other side of the chip contains a light-sensitive photo-transistor. The feedback signal on the secondary side is sent into the LED, and the signal is detected by the photo-transistor on the primary side. Thus, the opto-isolator provides a bridge between the secondary side and the primary side, communicating by light instead of electricity.6

The power supply also provides a negative voltage output (-12 V). This voltage is mostly obsolete, but was used to power serial ports and PCI slots. Regulation of the -12 V supply is completely different from the 5-volt and 12-volt regulation. The -12V output is controlled by a Zener diode, a special type of diode that blocks reverse voltage until a particular voltage is reached, and then starts conducting. The excess voltage is dissipated as heat through a power resistor (pink), controlled by a transistor and the Zener diode. (Since this approach wastes energy, modern high-efficiency power supplies don't use this regulation technique.)

The -12 V supply is regulated by a tiny Zener diode "ZD6", about 3.6 mm long, on the underside of the circuit board. The associated power resistor and transistor "A1015" are on the top side of the board.

Perhaps the most interesting regulation circuit is for the 3.3-volt output, which is regulated by a magnetic amplifier. A magnetic amplifier is an inductor with special magnetic properties that make it behave like a switch. When a current is fed into the magnetic amplifier inductor, at first the inductor will almost completely block the current as the inductor magnetizes and the magnetic field increases. When the inductor reaches its full magnetization (i.e. it saturates), the behavior suddenly changes and the inductor lets the current flow unimpeded. In the power supply, the magnetic amplifier receives pulses from the transformer. The inductor blocks a variable part of the pulse; by changing the pulse width, the 3.3-volt output is regulated.7

The magnetic amplifier is a ring constructed from ferrite material with special magnetic properties. The ring has a few turns of wire wound around it.

The control board

The power supply has a small board holding the control circuitry. This board compares the voltages against a reference to generate the feedback signals. It also monitors the voltages to generate a "power good" signal.8 This circuitry is mounted on a separate, perpendicular board so it doesn't take up much room in the power supply.

The control board has through-hole components on top and the underside is covered with tiny surface-mount components. Note the "zero-ohm" resistors marked with 0, used as jumpers.

The standby power supply

The power supply contains a second circuit for standby power.9 Even when the computer is supposedly turned off, the 5V standby supply is providing 10 watts. This power is used for features that need to be powered when the computer is "off", such as the real-time clock, the power button, and powering-on via the network ("Wake on LAN"). The standby power circuit is almost a second independent power supply: it uses a separate control IC, separate transformer, and components on the secondary side, although it uses the same AC-to-DC circuitry on the primary side. The standby power circuit provides much less power than the main circuit, so it can use a smaller transformer.

The black and yellow transformers: the transformer for standby power is on the left and the main transformer is on the right. The control IC for standby power is in front of the transformer. The large cylindrical capacitor on the right is part of the voltage doubler. The white blobs are silicone to insulate components and hold them in place.

Conclusion

An ATX power supply is complex internally, with a multitude of components ranging from chunky inductors and capacitors to tiny surface-mount devices.10 This complexity, however, results in power supplies that are efficient, lightweight, and safe. In comparison, I wrote about a power supply from the 1940s that produced just 85 Watts DC, but was suitcase-sized and weighed over 100 pounds. Now, with advanced semiconductors, you can hold a much more powerful power supply for under $50 that you can hold in your hand.

I've written about power supplies before, including a history of power supplies in IEEE Spectrum. You might also like my Macbook charger teardown and iPhone charger teardown. I announce my latest blog posts on Twitter, so follow me at kenshirriff. I also have an RSS feed.

Notes and references

1. Intel introduced the ATX standard for personal computers in 1995. The ATX standard (with some updates) still defines the motherboard, enclosure, and power supply configuration for most PCs. The power supply I examined is from 2005, so newer power supplies are more advanced and more efficient. The basic principles are the same, but there are some changes. For instance, regulation using DC-to-DC converters has mostly replaced the magnetic amplifier.

   

   The label on the power supply.

   The label provides information about the power supply I examined. It was built by Bestec for Hewlett-Packard's Dx5150 desktop PC. This power supply doesn't fit the ATX dimensions; it is longer and more rectangular. ↩

2. You might wonder why an AC input of 230 volts yields 320 volts DC. The reason is that AC voltage is normally measured as root-mean-square which (sort of) averages the varying waveform. As a result, a 230-volt AC signal has peaks of 320 volts. The power supply capacitors charge through the diodes to the peak voltage, so the DC will be approximately 320 volts (although it will sag somewhat through the cycle). ↩

3. The power transistor is an FQA9N90C power MOSFET. It can handle 9 amps and 900 volts. ↩↩

4. The integrated circuit is powered by a separate winding on the transformer that provides 34 volts to run the chip. You might notice a chicken-and-egg problem: the control IC creates the pulses to the transformer, but the transformer powers the control IC. The solution is a startup circuit consisting of a 100 kΩ resistor between the IC and the high-voltage DC. This provides a small current, sufficient to start operation of the IC. Once the IC starts sending pulses to the transformer, it is powered by the transformer. ↩

5. The technique of using one regulation loop for two outputs is called cross-regulation. If the load on one output is much higher than the load on the other, the voltages may diverge from their proper values. For this reason, many power supplies have a minimum load requirement on each output. More advanced power supplies use DC-to-DC converters for all the outputs to make sure they are precise. For more about cross-regulation, see this presentation and this presentation. One technique discussed is DC-stacking the output windings, a technique used in this power supply. Specifically, the 12-volt output is implemented as a 7-volt output "stacked" on top of the 5-volt output, yielding 12-volts. With this configuration, a 10% error (for example) in the 12-volt circuit would be just 0.7 V rather than 1.2 V. ↩

6. The opto-isolators are PC817 components, which provide 5000 volts of isolation between the two sides. Note the slot cut in the circuit board underneath the opto-isolators. This provides additional safety, ensuring that dangerous voltages cannot pass between the two sides of the opto-isolator along the surface of the circuit board, for example if there were contamination or condensation on the board. (Specifically, the slot increases the creepage distance.) ↩

7. The pulse width through the magnetic amplifier is set by a simple control circuit. During the reverse part of each pulse, the inductor is partially demagnetized. A control circuit adjusts the demagnetization voltage. A higher demagnetization voltage produces more demagnetization. This causes the inductor to take longer to re-magnetize and thus it blocks the input pulse for a longer time. With a shorter pulse passing through the circuit, the output voltage is decreased. Conversely, a lower demagnetization voltage produces less demagnetization, so the input pulse is blocked for a shorter time. Thus, the output voltage is regulated by changing the demagnetization voltage. Note that the pulse width into the magnetic amplifier is controlled by the control IC; the magnetic amplifier cuts these pulses shorter as needed to regulate the 3.3 V output. ↩

8. The control board contains multiple ICs including an LM358NA op-amp, a TPS3510P supervisor/reset chip, an LM339N quad differential comparator, and an AZ431 precision reference. The supervisor chip is interesting; it is specifically designed for power supplies and monitors the outputs to make sure they are not too high or too low. The AZ431 is a variant of the TL431 bandgap reference chip, which is very commonly used in power supplies to provide a reference voltage. I've written about the TL431 here. ↩

9. The standby power supply uses a different transformer configuration, called a flyback transformer. The control IC is an A6151, which includes the switching transistor in the IC, simplifying the design.

   

   Power supply circuit using the A6151. This schematic is from the datasheet so it is close to the circuit in the power supply I examined, but not identical.

    ↩

10. If you want to see detailed schematics of a variety of ATX power supplies, see danyk.cz. It's remarkable how many different implementations are used in power supplies: different topologies (half-bridge or forward), absence or presence of power factor conversion (PFC), and different control, regulation, and monitoring systems. The power supply I examined is moderately similar to the forward topology ATX supplies without PFC near the bottom of the page. ↩