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.
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:
BDCOK H (Pin 10 of the backplane connector, QBUS Pin BA1). This is one of the 2 input signals to the PDP-11 Processor that are used for power-up and power-down sequencing. During power up, it is set HIGH by the external source (the Arduino) before BPOK H is also driven HIGH by the external source. During power-down, it is pulled LOW by the external source after BPOK H has been pulled LOW. During normal operation (ie when BDCOK and BPOK are both HIGH) a short (at least 1 uSec) negative-going pulse on this line will cause the Processor to restart (and will cause the Processor to reset all peripherals, by pulsing the BINIT L signal)
BPOK H (Pin 1 of the backplane connector, QBUS Pin BB1). This is the second of the 2 input signals to the PDP-11 Processor that are used for power-up and power-down sequencing. It is driven by an external source (the Arduino). It must be debounced, as state changes on this line cause the PDP-11 to release or assert the BINIT L signal
BHALT L (Pin 9 of backplane connector, QBUS Pin AP1). This is the RUN/HALT input signal to the PDP-11 Processor. It is driven HIGH by the external source (the Arduino) to allow the Processor to run. The Processor will halt when this line is driven low by the external source
BEVNT L (Pin 2 of backplane connector, QBUS Pin BR1). This is the line time clock (LTC) signal to the PDP-11 Processor. It floats high. An external source (the Arduino!) pulses the line low at 60Hz (or optionally at 50Hz) when the Front Panel LTC switch is in the ON position. The waveform is a 50% duty-cycle square wave. When the LTC is disabled, this line should be HIGH
SRUN L (Pin 3 of backplane connector, QBUS Pin AF1). This line floats high and is driven low by the PDP-11 Processor when the Processor is running. When the Processor is halted, this signal is HIGH. I have observed two interesting things about this line: Firstly, the line pulses low when a console character I/O occurs when the Processor is halted. Secondly, when the Processor is running, the signal on this line is a high-frequency HIGH/LOW signal (with a pulse cycle time of around 6 uSec) rather than being held constantly LOW
GND (Pin 5 of backplane connector). This is the QBUS GND line. It connects to various QBUS Pins, including AC2 and BC2
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:
GND: Select any black wire on the ATX connector
+5VSB: This as an “always on” source of +5V from the ATX power supply. Use this to power the Arduino. This is the 9th pin from the +3.3V (Orange) end of the ATX connector, on the non-retainer-clip side. The wire is usually purple
PS-ON: The Arduino pulls this signal LOW (to GND) to turn on the ATX power supply. This is the 4th pin from the +3.3V (Orange) end of the ATX connector, on the retainer-clip side. The wire is usually green, but on my ATX Power Supply it was grey. With nothing connected to this signal, I found that on my ATX power supply it floats at 4.1V, and sinks 0.15mA when pulled to GND externally
PG: The ATX power supply sets this power-good signal HIGH (+5V) after the ATX Power Supply outputs have stabilised. This is the 8th pin from the +3.3V (Orange) end of the ATX connector, on the non-retainer-clip side. The wire is usually grey, but on my ATX power supply it was green
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:
Molex 03-06-2061 (aka Molex 0003062061) is the male 6-pin housing without mounting ears
Molex 03-06-1062 (aka Molex 0003061062) is the female 6-pin housing without mounting ears
Molex 02-06-2101 (aka Molex 0002062101) is the male pin for AWG 18-24 wire
Molex 02-06-1101 (aka Molex 0002061101) is the female pin for AWG 18-24 wire
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:
Pin 1: PS-ON (green)
Pin 3: +5VSB (purple)
Pin 4: GND (black)
Pin 6: PG (grey)
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:
|Front Panel Power Switch||This pin gets pulled to GND when the Power ON/OFF switch is in the ON position||A0
|Front Panel Run/Halt Switch||This pin gets pulled to GND when the Run/Halt switch is in the RUN position||A1
|Front Panel LTC Switch||This pin gets pulled to GND when the LTC ON/OFF switch is in the ON position||A2
|Front Panel Restart Switch||This pin gets pulled to GND when the Restart switch is in the ON position. This is a “momentary on” switch (spring loaded to the OFF position)||A3
|Front Panel “DC ON” LED||Connect to anode of “DC ON” LED. Cathode connects to GND via 270R resistor||A4
|Front Panel “RUN” LED||Connect to anode of “RUN” LED. Cathode connects to GND via 270R resistor||A5
|ATX power supply GND||Ground reference for the ATX Power Supply. Connect to any Black wire on the ATX connector||GND||GND|
|ATX power supply “+5V Standby” signal||This as the “always on” source of +5V from the ATX Power Supply, which is used to power the Arduino. This is the 9th pin from the +3.3V (Orange) end of the ATX connector, on the non-retainer-clip side. The wire is usually purple||5V||5V|
|ATX power supply “PS ON” signal||The Arduino pulls this signal LOW (to GND) to turn on the ATX power supply. This is the 4th pin from the +3.3V (Orange) end of the ATX connector, on the retainer-clip side. The wire is usually green, but on my ATX power supply it was grey||3||30|
|ATX power supply “Power Good” signal||The ATX power supply sets this signal HIGH (+5V) after the ATX power supply outputs have stabilised. This is the 8th pin from the +3.3V (Orange) end of the ATX connector, on the non-retainer-clip side. The wire is usually grey, but on my ATX power supply it was green. If you are not using an ATX power supply, tie this signal to +5V (otherwise the Arduino will not raise the QBUS BDCOK and BPOK signals)||4||31|
|QBUS GND||Ground reference for PDP-11. It connects to Pin 5 of the 10-pin backplane connector, and ultimately to various QBUS Pins, including Pins AC2 and BC2||GND||GND|
|QBUS “SRUN L” signal||This is an active-low signal from the PDP-11 processor that indicates when the processor is running. It connects to Pin 3 of the 10-pin backplane connector, and ultimately to QBUS Pin AF1 (but only in Row 1). At the Arduino end, we’re connecting this to the PCINT0 pin, to take advantage of the “pin change interrupt” functionality of the microcontroller on the Arudino||8
|QBUS “BEVNT L” signal||This is the LTC signal to the PDP-11 Processor. It connects to Pin 2 of the 10-pin backplane connector, and ultimately to QBUS Pin BR1. At the Arduino end, we’re driving this from an “output compare” signal controlled by a 16-bit timer. It’s a 60Hz (or optionally 50Hz) active-low square-wave signal||9
|QBUS “BHALT L” signal||This is the active-low HALT signal to the PDP-11 Processor. It connects to Pin 9 of the 10-pin backplane connector, and ultimately to QBUS Pin AP1. The Arduino pulls this line low to halt the Processor||7||47|
|QBUS “BDCOK H” signal||This is an input signal to the PDP-11 Processor. It is one of two signals that are used for power-up and power-down sequencing (the other one is “BPOK H”). It connects to Pin 10 of the 10-pin backplane connector, and ultimately to QBUS Pin BA1. It is driven by the Arduino. A second function of this signal is to “Restart” the Processor. This is achieved by applying a negative-going pulse to this signal once the system is in stable operation||5||48|
|QBUS “BPOK H” signal||This is an input signal to the PDP-11 Processor. It is one of two signals that are used for power-up and power-down sequencing (the other one is “BDCOK H”). It connects to Pin 1 of the 10-pin backplane connector, and ultimately to QBUS Pin BB1. State changes on this signal cause the Processor to release or assert the QBUS “BINIT L” signal||6||49|
|LTC frequency selection||This is an input signal to the Arduino. If it is left un-connected, the LTC will be 60Hz. If you want to generate a 50Hz LTC signal, tie this signal to GND||2||44|
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:
- Connect your Arduino board to your PC via a USB cable
- Download the Sketch for this project to your computer (see Downloads section below)
- Double-click on the Sketch. It should open in the Arudino editor
- From the “Tools” menu, select the Board type
- From the “Tools” menu, select the Port that your board appears at
- 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
- 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.
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.
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).
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.
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.
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.
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
- 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.
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.
Here is an assortment of photos showing the PDP-11 system used for this project.
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).
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:
M2012 = SP ON-NONE-ON, M2015 = SP ON-NONE-(ON)
E = .450” (11.4mm) Flatted
A2 = .280” (7.1mm) Smooth with Keyway
G = Gold; Rated 0.4VA max @ 28V AC/DC max [Contact Materials]
13 = .250” (6.35mm) Straight PC with .465” (11.8mm) Bracket [Terminals]
-ND = Unknown
Other similar projects
Here are links to similar projects by other people:
16 July 2017:
- Posted initial version, with source code version 1.0