Direct digital I/O ?

You could make up a USB to front panel emulator, much like the current USB keyboards do. Just configure it to issue the needed keystroke(s) when your front panel keys or switches are used. No need to go all the way back to the buss level, if indeed it is even available.

You might even be able to sell some of these to hobbyist that are not even using a Raspberry Pi but still want the retro look of a PDP panel.

Not me, but then I'm relatively new to the device myself.

Might be interesting. I've not seen anything other than memory cards that can go directly into the SD slot of any device and work.

Are you aware Western Digital is selling two hard drives designed specifically for the latest Raspberry Pi? They plug into one of the USB ports. I have one of the early 314GB drives and can run it directly off the Raspberry Pi3 with out the need of a USB hub or external power supply since I already had the higher powered USB power supply for my Pi.

or

Word is that they are trying to sell them world wide now so one of them might be worth looking into.

Not saying not to try and make something like a SATA to SD card slot converter but you might be facing an uphill battle on getting others to use it. ;)

A Pi with 26 way connector has 17 General Purpose In Out pins, some are allocated to particular interfaces, serial, SPI, I2C but can be used directly under software control as in or outs, individually, at the Pi's 3.3 V logic level. Used as an output they have enough grunt to light a LED via suitable series resistor. As inputs they have built in pull up (or down) resistors again under software control.

I wouldn't know a PDP8 or PDP11 front panel from an other historic computer front panel but even if 17 isn't enough they could be used in a matrix say 8 x 8 to produce 64 cross points. Pi's with the 40 pin connector have 27 GPIO's.

PDP 8 looks to have 30 switch positions and 27 lights = 57 which is less tha 64. B-) PDP11 would probably need a Pi3 or Zero and a matrix.

--
Cheers 
Dave.

I can remeber VARIOUS PDP-11 and PDP-8 systems with different amounts of switches and lights or even keypads or NO front panel. Even have some OLD books with them around (and various software listings).

I think you need to understand what a front panel on many older systems before the 80's were about. These front panels allowed, DIRECT examination or modification or memory, starting of code segments, even HALTING the CPU at next instruction, and a RESET switch.

The nearest method to ACTUALLY do the same functions would be by access to JTAG Boundary Scan and similar methods. The GPIO method would not be the same ata all.

Says he who remembers keying in bootloaders on many PDP-11's for single user to multi-user systems.

--
Paul Carpenter          | paul@pcserviceselectronics.co.uk 
    PC Services 
  Raspberry Pi Add-ons 
 Timing Diagram Font 
 For those web sites you hate

...Yes, the first mainframes I used had a row of 24 switches, an 'action' switch and a rotary selector. You used these to modify memory by inputting address/data pairs with these: patching the Executive program, your own code or even toggling in short programs or a bootloader. These machines also had engineer's panels with rows of lights. They could be plugged into a variety of positions in the CPU or peripherals and you slotted in the corresponding perspex plate to label the blinken lights with what they monitored.

The only system I've ever seen where there wasn't a direct and obvious connection between switches, blinkenlights and the hardware was one of the early microprocessors - the IMSAI 8080, which was based on an Intel

8080. It had a front panel that was very similar to a PDP-8. IIRC it could show internal states of the 8080 but I never understood how. My best guess is that it had some firmware that could grab register contents, etc and copy it to a piece of static RAM that acted as a buffer between the switches&lights on one side and the firmware/MPU on the other.

That sort of approach will probably not work for an RPi since there's nothing that can easily serve as buffer memory and no easy/obvious way to add it. Then again you'd need an awful lot of switches and LEDS: the PDP-8 used 12 bit addresses and 12 bit words and the 8080 used 16 bit addresses and 8 or 16 bit registers but the RPi uses 32 bit addressing and 32 bit registers. And that's only the RPi 1 with a single core MPU - do you want to monitor the GPU too (good luck with that) and what about the other three cores on a Pi 2 or 3?

--
martin@   | Martin Gregorie 
gregorie. | Essex, UK 
org       |

Your memory is failing you. It could show the address/data bus and the internal states you refer to were all signalled via pins on the CPU such as interrupt enable, hold, ready, rd/wr. No firmware needed, just a direct connection. There was probably a few TTL gates needed to implement single step logic and debounce on the step/deposit function buttons.

The IMSAI had better switches than the Altair 8800b. It looked more the part and more like DEC machines of the period. 41 years since its launch but it doesn't feel like that.

Unsurprising: I've only seen an IMSAI 8080 in a store window (The Computer Shop, NYC on or near 35th and 5th) and somewhat later when one starred in the "War Games" movie. I've never used the beast.

I remember it looking great and wondering how much that panel cost to make.

However, my main point still stands: that compared to the IMSAI 8080, PDP8, PDP11, or any of the late 60s mainframes, a similar panel for an RPi would need a ridiculous number of LEDs and switches simply due to the register and address widths.

--
martin@   | Martin Gregorie 
gregorie. | Essex, UK 
org       |

Oh. I thought the idea as to have the PI emulating a PDP-8!

--
"The great thing about Glasgow is that if there's a nuclear attack it'll  
look exactly the same afterwards." 

Billy Connolly

Of course today you would not use individual LEDs but an LCD or LED graphic display panel. However, that would mean you need to run software to copy the machine state to that display, while the early computers had the leds actually wired to the values they displayed.

As pointed out, it was not usual for frontpanels to display the content of all registers. Normally it was a display of address and data bus, and sometimes some special registers like program counter.

Those could be grabbed from the address/data bus by decoding control lines (e.g. on an 8080 external logic could decode that the PC was on the address bus vs. a data memory access).

Yes they could - that was how (some[1]) in circuit emulators for processors of that era worked, a real processor with all the pins monitored and logged in real time while software tracked the state of the internal registers.

Of course the real front panels from before microprocessors ruled the roost were directly wired to the registers which would be rather hard even on an 8080 never mind a pi-3 - you'd need a clean room for starters.

[1] The others were usually bit-slice emulations with direct access to the registers but inaccurate timing.

--
Steve O'Hara-Smith                          |   Directable Mirror Arrays 
C:>WIN                                      | A better way to focus the sun 
The computer obeys and wins.                |    licences available see 
You lose and Bill collects.                 |    http://www.sohara.org/

8080,

for an

to

The idea being have a PDP-8 or 11 panel that behaved like the orginals driven by a Pi. Not to have a panel that performed same fuction on a Pi.

Building the panel, leds, display latches etc probably isn't that hard, could be done withe discreets but getting the register stucture of a Pi core and access to those values might be fun in software. But without filing the top off the SOC and attaching rather a lot of very fine wires is never going to be direct.

--
Cheers 
Dave.

It is far EASIER to EMULATE a PDP-8 or PDP-11 graphically on screen than I/O driven, as the code would have to be run through instruction code emulator and easier to create mimics for the type of front panel.

That way you can choose which panel you want as PDP-11 types WERE different.

/05 or /10 3U high front panel one row of awitches and ONE row of LEDs (16 address or data switches)

/20 6U high front panel one row of switches (18 for address or data) two rows of LEDs

/45 6U high front panel one row of switches (18 for address or data) two rows of LEDs and other LEDs

/70 6U high front panel one row of switches (21 for address or data) two rows of LEDs and other leds

/34 and /60 various size front panels with minimal switches or keypads and led 7 seg displays (some were centre upright strip of large cabinet)

/03 and /23 Actually micros not sets of processor boards and NO front panel

Thats some of the variants I played with had my own 11/05 under my lab bench, or ran Engineering multi-user systems first on 11/45 then 11/70, from memory I am sure there were others.

Then we went to VAX and no front panel

--
Paul Carpenter          | paul@pcserviceselectronics.co.uk 
    PC Services 
  Raspberry Pi Add-ons 
 Timing Diagram Font 
 For those web sites you hate

The main issue comes around the ONE switch and what it would then do in your software to control the panel, namely the Halt/Start switch. Would this halt/start your

Front panel emulator Your code being emulated the system

Let alone issuing RESETs from front panel

Regardless of numbers of switches, tha ability to write to any memory location on the Pi (RAM or I/O registers) any value would be a nightmare

As said in another post this is only sensibly done as a graphical mimic or similar, making it access the Pi internals is actually destructive as could cause problems in many ways bricking system or SD card.

Is only really viable as part of an emulator for code for those processors as a mimic graphic to control the emulation run.

I know someone who once tried to implement with large FPGA the front panel and code emulation of a PDP-1 (yes ONE) on a credit card sized board.

--
Paul Carpenter          | paul@pcserviceselectronics.co.uk 
    PC Services 
  Raspberry Pi Add-ons 
 Timing Diagram Font 
 For those web sites you hate

On Sat, 11 Jun 2016 08:37:09 -0000 (UTC), Martin Gregorie declaimed the following:

And another processor just to handle the interface... Is an address bus even exposed on these SoC? (I suppose for DRAM). Most of the peripherals are either internal to the chip, or are using some serial protocol for data transfer. Address width could be handled via HIGH/LOW inputs (still want lots of LEDs for readback). Similar for data input.

Altair/IMSAI mostly needed a set of tri-state latches with the switches/LEDs... Set switches for address, momentary contact switch to latch (address bus is now locked) -- maybe automatically pulse the data read line and latch to display. Set data switches, momentary contact to latch/write to memory. Tri-state turned off when RUN switch activated so LED just flicker whatever the processor was emitting...

--
	Wulfraed                 Dennis Lee Bieber         AF6VN 
    wlfraed@ix.netcom.com    HTTP://wlfraed.home.netcom.com/

Proper computers with "blinkenlichts" used low current filament bulbs and not LEDS as they predated the LED's invention by many years. Such as my old Data General Nova 1200.

Or, in the vacuum tube days, neon bulbs. ;-)

My favorite was the Burroughs B220, which had over 200 neons on its console, and twice that when its console "maintenance panels" were opened. Each lamp was accompanied by a pushbutton that allowed setting or resetting that bit.

It had so many lights that, refitted with incandescents for filming, it was a favorite "computer" in numerous films and TV shows--perhaps most famously, Batman. ;-) (Batman also had a smaller computer in some earlier episodes, which was the console of the B220's older, littler brother, the Electrodata 205.)

--
-michael - NadaNet 3.1 and AppleCrate II:  http://michaeljmahon.com

Yep - I used to use a GEC 4080 minicomputer from the front panel. With some 80 or so filamant lamps, some were inevitably dead, so there was an art to being able to use the front panel in spite of some of the lamps not working. Circular shifting a register from the front panel was one way (and then shift it back). The other was to pinch spare lamps from indicators you didn't care about and fit them in the ones you needed (or pinch them from another machine if there was one).

Many years ago, I wrote a GEC4080 emulator (which will run on the Pi, although that wasn't the point). The front panel is implemented using GTK+ as an X windows emulation of the original. I didn't think to emulate dead lamps - maybe I should?

--
Andrew Gabriel 
[email address is not usable -- followup in the newsgroup]

Actually not what was originally stated

=---start quote Inspired by Oscar Vermeulen's emulations of PDP8 and PDP11 front panels (I've used both processors, in my time over the past 40 years) but as yet inexperienced in the RPi world (despite getting Pi1 2 years ago and Pi2 one year ago :-( ), I'd like to consider producing a similar front panel low-level access for the RPi itself. =---end quote

Note the last sentence.

--
Paul Carpenter          | paul@pcserviceselectronics.co.uk 
    PC Services 
  Raspberry Pi Add-ons 
 Timing Diagram Font 
 For those web sites you hate

Interesting that the above has fomented a lot of negative thinking and defeatism, and, for the moaners in those categories, yes, I agree wholeheartedly, that it wouldn't work out for you.

I had in mind a miniscult monitor program, with NMI being driven from the ersatz Halt switch, and to use the built-in debug instructions to perform single stepping.

I suppose you realise that in a RPi the GPU is started first and it in turn executes the first stage bootstrap, which in turn loads and boots the Linux kernel? That means you'll need to persuade the first stage bootstrap to load your monitor and then load the Linux kernel above it at a modified address so it doesn't overwrite your monitor?

Doing that will almost certainly need access to proprietary information, so think license fees and NDA agreements, and you're still stuck with the problem of connecting switches and LEDs to a series of 32 bit wide items (address bus, data bus and registers).

I have experience of using similar switches and lamps on a 24 bit word- based bigendian mainframe. It was hard enough to get the settings right on that, but attempting the same trick on a little-endian 32-bit system seems like the perfect recipe for data entry mistakes.

I've also written my own monitor for a 8/16 bit 6809, also a bigendian architecture. It never occurred to me to work at the bitstring level on that because inputting and reading hex via screen and keyboard was so much easier to use.

--
martin@   | Martin Gregorie 
gregorie. | Essex, UK 
org       |