QBUS Front Panel Project

This project is an Arudino-based front panel for a bare QBUS PDP-11 chassis.

It provides the switch and indicator functionality typically found on an early QBUS PDP-11 chassis (such as a BA11-MF or BA11-NC) and does the following:

• Switches an ATX power supply on and off, to power the PDP-11
• Drives the PDP-11’s BDCOK H and BPOK H lines during power-up and power-down
• Provides a 60Hz (or 50Hz) line time clock (LTC) to the PDP-11’s BEVNT L line
• Drives the PDP-11’s BHALT L line, based on the position of the front panel RUN/HALT switch

The reason this project exists is because building a working minimal PDP-11 system involves a small amount of complexity. It is not sufficient to just add a DC power supply to the PDP-11 backplane, as there are some control signals that are required by the PDP-11 Processor (BDCOK H, BPOK H, BEVNT L and BHALT L) and which must be supplied externally. In original DEC equipment, these signals would typically be provided by circuitry in the DEC power supply in combination with a 3-switch and 2-LED front panel. If you do not have the original DEC power supply and front panel, these control signals need to be synthesised.

This project will enable a QBUS PDP-11 backplane (such as a H9270, H9273 or H9281) when populated with an appropriate collection of PDP-11 boards, to function as a minimal PDP-11 system, as shown in the picture to the right here. It follows on from other similar published designs, in particular the approach well described on Diane’s PDP-11 Page.

If you are thinking of building this project, I recommend that an ATX power supply be used to power the PDP-11 backplane. This is because the Arduino will turn the power supply’s +5V and +12V outputs on and off by controlling the power supply’s “PS ON” input. It should work with either an ancient (20-pin) or relatively modern (24-pin) ATX power supply.

This project will work with an Arduino UNO, or an Arduino Mega 2560. Simply select either of these boards (under Tools -> Board in the Arduino IDE) and the program will correctly compile for that board. You do not need to make any changes to the Arduino source code to select the Arduino model.

When using an Arduino Mega 2560, all connections to the QBUS backplane, ATX power supply and front panel LEDs/switches are done through the double-row header at the end of the Arduino Mega. When using an Arduino UNO, almost all available I/O pins are used by this project.

It is intended that the Arduino be powered by the ATX power supply’s “+5VSB” output. This is an always-on source of +5V, which is present even when the power supply is in standby mode (so long as the ON/OFF
on the rear of the ATX power supply is turned on).

DEC’s original design

An early PDP-11/03 system would typically be housed in a DEC BA11-MF, BA11-NC or similar chassis. For the purpose of this discussion, we’ll look at the BA11-MF.

The BA11-MF chassis included the following key sub-assemblies:

• A H9270 backplane
• A H980 power supply
• A front panel with 3 toggle switches and 2 LEDs

The BA11-MF chassis front panel switches included a DC On/Off switch, a Run/Halt switch, and a LTC On/Off switch. All 3 of these switches were dual-position toggle switches (they latched in either the Up or Down positions). It also included two LEDs. The “DC ON” LED indicated when DC power was on, and the “RUN” LED indicated when the PDP-11 Processor was running. The later BA11-NC chassis used a very similar front-panel arrangement, but deleted the LTC switch and replaced it with a momentary-on Restart toggle switch.

Here are some pictures of a BA11-MF chassis, with the PDP-11 PCBs removed:

QBUS Backplane 10-Pin Connector

This project is primarily designed to work with DEC backplane models 9270, 9273 and 9281. These each have a 10-pin connector on the reverse side of the backplane. It is this connector (which is a 5×2 array of pins with 0.1″ spacing) that interfaces the BDCOK, BPOK, BEVNT, BHALT and SRUN signals to the PDP-11 processor. The picture on the right here shows the 10-pin connector on the rear of a H9270 backplane, in a DEC BA11-MF chassis.

This project will likely also work with other QBUS backplanes (whether made by DEC or various other companies) that have the same 10-pin connector. However, I suggest first carefully buzzing through the signals (between the 10-pin connector and the QBUS pins they connect to) to make sure the backplane wiring is standard. Importantly, please note that the BA23 and BA123 differ from the H9270 in one critical respect: Pin 1 on the BA23/BA123 is a +12V output from the backplane (rather than being the BPOK input pin). So do NOT connect Pin 1 of the BA23/BA123 10-pin connector to any Arduino pin. You will likely destroy the Arduino. It is unfortunate that DEC re-purposed Pin 1 in this manner (all other pins of the 10-pin connector on the BA23/BA123 seem to be compatible with the H9270).

Sometimes it can be difficult to determine which pin of the 10-pin connector is “Pin 1”. The easiest way to verify this is to first locate Pin 4 (which is missing on genuine DEC backplanes). Once that pin location has been found, Pin 1 is easy to locate (it is the corner pin that happens to be one pin offset from Pin 4, but in the opposite row).

Here is a brief description of the 6 pins that we will be using on the 10-pin backplane connector:

I have verified the QBUS Pin numbers listed above by buzzing out a H9281 backplane. SRUN L only connects to the Processor row. The other signals are bussed to all 4 rows.

If you are not familiar with the pinout numbering/naming convention for the QBUS connections, you will find full details in the user manuals for the PDP-11/03 or PDP-11/23 Processor boards. However, this webpage is a helpful summary if you don’t want to go digging in the DEC manuals.

BDCOK and BPOK Signals

Various DEC manuals provide detailed timing diagrams showing how these signals are to be driven during power-up and power-down sequences. See for example Section 3-9 and Figure 3-18 of the LSI-11, PDP-11/03 User’s Manual (DEC P/N EK-LSI11-TM-002).

The purpose of these two signals is described fairly succinctly in the two images shown on the right here (you can click on them to see a larger version). As can be seen in these two images, BDCOK is raised first (to HIGH) during the power-up process, and BPOK is then raised. The raising of BPOK causes the PDP-11 Processor to release the BINIT L line, this completing the process of initialising connected PDP-11 peripherals.

During the power-down process, BPOK is lowered first, and BDCOK is then lowered. The lowering of BPOK causes the PDP-11 Processor to commence an orderly shutdown process.

Perhaps the most complex part of this project was designing a software state machine (within the Arduino source code) that gives effect to the required power-up and power-down timing, based on the position of the front panel Power On/Off switch. For example: As well as sequencing the BDCOK and BPOK signals, the state machine turns the ATX power supply on or off (as appropriate) and waits for the ATX power supply to deliver a valid “Power Good” signal before raising the BDCOK signal to HIGH.

It is also interesting, based on the information in the images shown on the right here, that a Processor “Restart” can be achieved by pulsing BDCOK H to LOW for 1 uSec or more during normal operation. This project takes advantage of that capability.

ATX Power Supply

A surplus ATX power supply can be used to power the QBUS PDP-11 system. The ATX power supplies that I had laying around have either 20-pin or 24-pin connectors. I used a 20-pin version for this project. The pinout of the main ATX connector is shown on the right here for both the 20-pin and the 24-pin version. You can click on the image to see a larger version of these diagrams.

Connect the GND, +5V and +12V outputs from the ATX power supply directly to the PDP-11 backplane. I did this via one of the 4-pin floppy drive connectors that exit the ATX Power Supply. Most QBUS boards only require GND, +5V and +12V.

Four of the signals available at the main ATX power connector need to be connected directly to the Arduino:

There is some interesting information about the ATX “Power Good” signal on this Wikipedia page. Note that some cheap ATX power supplies may fake this ATX signal (by simply connecting it to the +5V rail). This would prevent the Arduino from achieving the required timing for the QBUS BDCOK and BPOK signals.

To connect the ATX power supply to the Arduino I used Molex 1625 Series connectors, as shown in the picture on the right. These accept Molex 1.57mm (0.062″) pins. I wired the female connector to the ATX power supply, and the male connector to a cable leading to the Arduino. At the ATX end, I grafted the 4 wires on to the wiring loom where it exits the power supply. I soldered these connections and covered them with heatshrink tubing.

The Molex part numbers for this 6-pin connection are:

If you can’t find stock of the pins listed above, look for other Molex 1560 Series (for male pins) and Molex 1561 Series (for female pins). There are a variety of part numbers depending on type of plating, wire size and packaging (strip form, loose, etc). Similarly, if you can’t find stock of the housings listed above, look for other Molex 1625 Series housings. They vary based on colour (black or natural) and whether or not they have mounting ears.

The pin assignment that I used for the Molex 1625 Series connector was:

Construction details

The picture on the right shows the internal wiring of the front-panel box.

The main components that you will need are:

• A QBUS PDP-11 backplane
• An ATX power supply
• Four toggle switches (POWER, RUN/HALT, LTC and RESTART). The restart switch is a momentary switch (this is known as an “ON-NONE-(ON)” switch). The other three switches latch in the up on down position (these are known as “ON-NONE-ON” switches). None of the switches have a “centre off” position
• Two LEDs and mounting bezels (DC OK and RUN)
• Two 270R 0.25W resistors (one for each LED)
• An Arudino UNO or Arduino Mega 2560
• A case to house the Arduino, switches and LEDs
• Wiring to connect the switches/LEDs to the Arduino. I used Male-Male jumper leads for this, with one end cut off
• A length of data cable to exit the front panel box. The other end connects to the ATX power supply and the QBUS backplane. I used a short length of 8-way data cable that has an overall screen. The downside of this approach was that the screen had to be used as the GND conductor for connection to both the ATX power supply and the QBUS backplane. A larger data cable (say 10 conductor) would have been a better choice
• A way of terminating, at the ATX power supply, the 4 wires from the Arduino. See my comments above regarding the Molex connector that I used
• A way of terminating, at the 10-pin connector on the rear of the QBUS backplane, the 6 wires from the Arduino. I used a 10-pin IDC connector with a short length of ribbon cable

Mount the switches and LEDs on the lid of the box. Then get the data cable (to the ATX power supply and PDP-11 backplane) physically mounted through the side wall of the box. I used a cable clamp here. However, the side wall was too thick for the cable clamp and I ended up having to epoxy the whole assembly in place.

You should then be ready to complete the internal and external wiring connections. The picture on the right shows how the data cable from the box transitions to the connectors for the PDP-11 backplane and the ATX power supply. I made extensive use of soldering and heatshrink tubing here. I’m sure there are better ways to do this, but this technique seems to work OK.

Here are the connection details. The Arudino pin numbers quoted below are as they appear on the Arudino PCB silkscreen:

Once you have completed the construction, its time to “upload” the Arduino program to the board. This is best done using the Arduino IDE. Note that in the Arduino world, the Arduino source-code file is called a “Sketch”. The Sketch for this project is a single source-code file. It has the standard Arduino “.ino” suffix.

I won’t go into any great detail about how to do this. But if you have any problems figuring this out, please let me know and I will try to help sort it out. Here are the basic steps you need to follow:

1. Connect your Arduino board to your PC via a USB cable
2. Download the Sketch for this project to your computer (see Downloads section below)
3. Double-click on the Sketch. It should open in the Arudino editor
4. From the “Tools” menu, select the Board type
5. From the “Tools” menu, select the Port that your board appears at
6. Click on the Upload button in the IDE (this is the icon that looks like a large right arrow). This will compile the Sketch and program it into your Arduino board via the USB cable
7. Check the message box (black section) at the bottom of the Arduino IDE, to verify that no compile or upload errors occurred

One thing you must give consideration to is cooling for the PDP-11 boards. You will find that after 20-30 minutes or so that the boards get quite hot. If you are going to run the boards for longer than that, you will probably need to find a way to mount a cooling air fan on the side of the QBUS chassis.

Program description

The program is fairly simple. Its main task is to monitor the position of the front-panel switches, and vary the output signals when a switch changes position.

Program entry points

The program has two entry points, as required by the Arduino architecture. The routine called setup() executes once (and only once) each time the Arduino is powered up or reset. This is where many variables are initialised, and various Arduino hardware options are configured. The routine called loop() executes repeatedly when the Arduino is running. Actually there is a third entry point: the interrupt routine called ISR(PCINT0_vect). I’ll mention that in more detail below when talking about the SRUN input.

Switch debouncing

The 4 front panel switches are software debounced by a 60 mSec timer. The debounce is applied to every state change (off to on, and on to off). This is achieved by polling the status of each switch once per millisecond. If a state change is detected, the debounce timer for that switch starts to count upwards. The debounce timer is cleared to zero if the switch reverts to its previously stable state before the debounce timer expires. If the debounce timer does climb to 60 mSec, the new switch state is registered, and this becomes the current “stable” state for that switch.

Power ON/OFF switch

Perhaps the most complex part of the program is the state machine that takes care of the power-up and power-down sequence. The variable power_state holds the current value of this state machine. When the front panel power switch is turned on, the state machine goes through the following sequence of actions:

• The ATX power supply is turned on (by pulling the PSON output pin LOW)
• Once the ATX “Power Good” signal is detected HIGH by the Arduino, the DC ON LED is illuminated
• No further action is taken for 3 mSec, to allow the power supply outputs to stabilise
• The Arduino’s BEVNT and BHALT pins are re-configured to be outputs
• The BDCOK pin is asserted HIGH
• No further action is taken until a 70 mSec timer expires
• The BPOK pin is asserted HIGH
• No further action is taken until a 3 mSec timer expires
• The power_state is deemed to be “PWR_STABLE”

A similar but less complex sequence of events occurs when the front panel power switch is turned off. In the meantime, the “Power Good” signal from the ATX power supply is continually monitored. If that signal falls to LOW, the Arduino automatically commences the process of powering-down the PDP-11 (through proper sequencing of the BPOK and BDCOK signals).

RUN/HALT switch

When the RUN/HALT switch changes position, the program simply updates the status of the BHALT output pin. When the switch is in the RUN position (up), the BHALT L line is set HIGH. When the switch is in the HALT position (down), the BHALT L line is set LOW.

Run LED

The position of the RUN/HALT switch does NOT directly control the status of the front panel RUN LED. Instead, that LED reflects the status of the SRUN input pin.

The SRUN L signal from the PDP-11 is connected to the PCINT0 input pin on the Arduino. The program configures this pin to take advantage of the Arduino’s “pin change interrupt” capability. So every time a state change (low to high, or high to low) occurs, this generates an interrupt which causes the Arduino to execute the code at ISR(PCINT0_vect). The interrupt routine initialises a 250 mSec re-trigerable one-shot software countdown timer. While that timer is non-zero, the RUN LED is illuminated. Once the timer expires, the RUN LED is extinguished. Each time the interrupt occurs, the one-shot countdown timer is re-initialised, and further interrupts are blocked for 100 mSec. This is to avoid the Arudino spending time unnecessarily responding to every state change on the SRUN line (when the PDP-11 is running, the SRUN L signal cycles about once every 6 uSec).

On reflection, it is probably not necessarily to actually invoke an interrupt to detect SRUN L changes of state. It would be adequate to leave pin change interrupts disabled, and simply monitor and clear the pin change interrupt flag as part of the loop() tasks. I may change this in a later version of the program.

LTC ON/OFF switch

When the LTC switch is in the off position (down), the Arduino sets the BEVNT L output line HIGH.

When the LTC switch is moved to the on position (up), the Arduino outputs a simulated “line time clock” on the BEVNT L line. This signal will usually be a 60 Hz 50% duty cycle square wave. However, if you have inserted a link between GND and the LTC_SPEED_SELECT pin (see connection list above for relevant Arduino pin number) then the signal will be 50 Hz rather than 60 Hz. Note that the speed-select pin is sampled only when the LTC switch is moved to the ON position. So you will need to cycle the LTC switch if you change this jumper, before the change will take effect.

The LTC output is generated using one of the Arduino’s built-in hardware timers, using an advanced mode of the timer that can automatically toggle an output pin when the timer reaches the output-compare value. This mode is known as “toggle on compare match”. By using this technique the program does not need to manually toggle the BEVNT L line high and low. It happens automatically once the timer has been properly configured.

Note that the LTC switch should normally be in the OFF position when booting a PP-11 operating system (eg RT-11 or XXDP). Otherwise the operating system may fail to start.

Restart switch

The restart switch is a momentary switch that rests in the off position (down). When moved to or held in the on position (up) it generates a restart condition by toggling the BDCOK H line low for a fixed one-shot period of 50 uSec. This functionality is incorporated in the power_state state machine. When the restart switch is manually toggled to the on position, power_state changes to PWR_RESTART_REQUESTED. The state machine then takes care of the subsequent actions required.

Heartbeat LED

The Arudino PCB includes a LED that is connected to the Arduino pin defined as “LED_BUILTIN”.

The program uses that LED as a simple status output to show that the Arduino program is running normally. Every 3.0 seconds the LED will pulse on briefly for 50 milliseconds.

BEVNT and BHALT pins

“BEVNT L” and “BHALT L” are outputs from the Arduino to the PDP-11 Processor. However, to avoid driving a logic 1 (+5V) out on these lines when the PDP-11 is powered down, these signals are initially configured as inputs to the Arduino, until the ATX power supply has been commanded to turn on. Similarly, they revert to being inputs when the ATX power supply is being commanded to turn off.

My test setup

The main components that I used in developing and testing this setup are shown in the picture on the right.

They include:

• DEC H9281 4-slot QBUS backplane
• 250W 20-pin ATX power supply
• PDP-11/23 Processor (DEC M8186)
• 256KB of RAM (Fourth Generation Systems LS256-1)
• 4-Port SLU (Camintonn CMLV11-J)
• RQDX3 MFM hard drive and floppy controller (DEC M7555)

Note that this system does not include any boot ROMs. So normally you would need to type in a bootloader via the console at the ODT prompt. However, I have another Arduino-based project (not yet published) which displays an on-screen boot menu. You select the boot device on the console, and the Arduino then types the bootloader code for you. There is a screen shot in the picture gallery below that shows this on-screen boot menu.

I have tested this system with DU devices (RD31 and RX33) as well as DD devices (TU58 emulator). It has successfully booted RT-11 and XXDP from these devices.

BA23 and BA123 Backplanes: CAUTION!

The 10-pin connector on the BA23 and BA123 backplanes differ from the description above in at least two respects. The first point is CRITICAL:

• Pin 1 (which is BPOK on the H9270 backplane) is a +12V output from the backplane. Do NOT connect this pin to any Arduino pin! BPOK instead needs to be connected to Pin 15 on the BA23/BA123 18-pin power supply connector. It is NOT available on any pin of the 10-pin connector.
• Pin 4 (which is the key pin on the H9270) is a key pin on the BA23, but is NOT a key pin on the BA123 (all 10 pins are present on the BA123).

The BA123 brings the +5V from each of the two regulators to the front-panel PCB (via the 10-pin connector), so there will be divergences from the H9270 wiring in this area as well.

Some (but not all) of the control and status signals on the H9270 10-pin connector are available on the BA23/BA123 18-pin power supply connectors:

• BDCOK (QBUS Pin BA1, H9270 10-pin connector Pin 10) is available on Pin 14 of the 18-pin power supply connector
• BPOK (QBUS Pin BB1, H9270 10-pin connector Pin 1) is available on Pin 15 of the 18-pin power supply connector
• BEVNT (QBUS Pin BR1, H9270 10-pin connector Pin 2) is available on Pin 16 of the 18-pin power supply connector

Note also that the BA123 backplane actually has 2 x 18-pin power supply connectors. J1 is the upper connector (adjacent to Slots A and B) and J2 is the lower connector (adjacent to Slots C and D). BDCOK and BPOK connect to both J1 and J2. BEVNT connects only to J1.

For reference purposes, here are the power-pin connections on the 18-pin connectors:

• Pins 1-6 (Wire colour is Red): +5V. Note on the BA123 J1 goes to odd-numbered rows and J2 goes to even-numbered rows
• Pins 7-13 (Wire colour is Black): GND
• Pin 17 (Wire colour is Orange): +12V
• Pin 18 (Wire colour is Yellow): Purpose unknown. Measured voltage in a working BA123 PDP-11/73 system was 0.0V

Downloads

Below is the link to the source code for this file. Use the Arduino IDE to open or edit this file, and to “upload” the file to your Arduino board.

Although this file has a “.ino” extension, it is just a plain-text c-language file. You can open it in a text editor for viewing.

Photo Gallery

Here is an assortment of photos showing the PDP-11 system used for this project.

Miscellaneous notes

You probably won’t need to know the information in this section. These are just miscellaneous thing that I’ve noted during the development of this project, which I may need in the future.

The H780 schematics show the following in relation to the BDCOK H and BPOK H signals:

• BPOK H: This pin is tied to +5V via a 10K resistor, and pulled to GND via a small MOSFET
• BDCOK H: This pin is tied to +5V via a 10K resistor, and pulled to GND via a small MOSFET

I took some measurements as to the voltages on the 10-pin connector on the rear of the QBUS backplane, and the current required to pull the relevant signals to GND. The test setup was a H9281 backplane fitted with a PDP-11/23 Processor (M8186), 256KB of RAM (Fourth Generation Systems LS256-1), 4-Port SLU (Camintonn CMLV11-J) and an RQDX3 (M7555). This is what I observed (with no cable connected to the 10-pin connector):

• Pin 1 (BPOK H): Floats at 3.2V. Sinks 14.3 mA when pulled to GND externally.
• Pin 2 (BEVNT L): Floats at 3.2V. Sinks 14.3 mA when pulled to GND externally.
• Pin 3 (SRUN L): Stable at 4.2V.
• Pin 9 (BHALT L): Floats at 3.2V. Sinks 14.4 mA when pulled to GND externally.
• Pin 10 (BDCOK H): Floats at 3.2V. Sinks 14.4 mA when pulled to GND externally.

ATX Power Supply 20-Pin Right Angle connector: Amphenol FCI 10127819-20211LF (Element14 P/N 2463316, $1.11 each). Engineering Drawing is here. The 24-pin version is available from Core Electronics (P/N PRT-09498, drawing here).

DB9 Right-Angle Female PCB Socket: Available from Core Electronics (P/N 003-DSUBPCF9, drawing here)

PCB-mount vertical toggle switches: This project would use 3 x On-None-On switches (Digikey M2012EA2G13-ND by NKK) and 1 x On-None-(On) switch (Digikey M2015EA2G13-ND, by NKK). These are both part of the NKK M20 series, and are covered by this drawing (see top half of last page).

The NKK switch part numbers are decoded as follows:

Other similar projects

Here are links to similar projects by other people:

Revision History

16 July 2017:

• Posted initial version, with source code version 1.0

8 October 2017:

• Added text explaining differences between H9270 and BA23/BA123 backplane connectors