PCjs and Sticky Machines

PDPjs is able to run a variety of old DEC operating systems, such as RT-11 and RSTS/E, and while there are manuals available online, thanks to the efforts of those who operate and contribute to websites like bitsavers.org, I suspect most people don't have a lot of interest or time to spend reading old manuals.

In an effort to remedy that situation, I'm adding some new features to PCjs. The first feature is what I call "Sticky Machines", and it's really just a new feature of the PCjs website. At the top of any PCjs webpage, in the machines section, a machine can now define a sticky property. For now, the only supported value is "top"; e.g.:

machines:
  - id: vt100
    type: pc8080
    config: /devices/pc8080/machine/vt100/machine.xml
    connection: serialPort->test1170.dl11
    sticky: top

A sticky machine makes it easier to construct a tutorial page for a single machine, by preventing that machine from scrolling off the top; it "sticks" to the top instead. The rest of the page scrolls normally, allowing the user to progress at their own pace through the text and/or images of an accompanying tutorial.

The second feature is a generalized method for sending commands to components within a machine. For example, if we want to send some serial data to a machine:

{% include machine-command.html type='button' label='Try It!' machine='vt100' component='SerialPort' command='receiveData' value='Hello World' %}

which should translate into a control that looks like:

<button type="button" onclick="commandMachine('vt100','SerialPort','receiveData','Hello World')">Try It!</button>

Obviously, every component we want to control will need to be updated to export the necessary "command" functions.

So expect some PDPjs tutorials in the near future, featuring sticky machines and built-in command demos. Some commands will be very simple, like the data injection command shown above. Others will perform more sophisticated operations, such as loading and booting a particular disk, running a particular application, automatically flipping selected Front Panel switches, and so on.

[NOTE: There was a v1.32.0, but it was largely just a "new year" update. I don't think there were any important changes in that update, which is probably why I forgot to mark it as a new release.]

PC8080 Now Uses ES6 Features

Like PDPjs, PC8080 now uses ES6 features, too.

In addition, there's a new "pdp11" shell app that makes PDPjs work from the command-line (within Node).

PDPjs Now Uses ES6 Features

PDPjs is the first PCjs machine that now uses selected ES6 features, including:

• Classes
• Default Parameters
• const and let
• Computed Properties
• Octal and binary constants
• Template Literals (for string interpolation; i.e.: ${…})

The conversion from ES5 to ES6 classes was the most substantial change. The rest of the features have only been used sporadically, as I stumble across code that could benefit from the improvements in ES6 syntax.

Also, since only PDPjs has been converted thus far, I had to fork the shared code in /modules/shared/lib into its own ES6 folder in /modules/shared/es6. Once all PCjs machines have been converted to ES6, the contents of the shared /es6 folder will be folded back into the original /lib folder. In the interim (which will hopefully be short), any changes to shared code will have to be made in both places, and any attempt to run two or more machines on the same page with different shared modules will fail -- but that only affects users running uncompiled code.

You probably won't see a big difference in the compiled code, because I've configured Google's Closure Compiler to "transpile" to ES5. Even though all the browsers that PCjs supports now include support for all the ES6 features that I'm using (which isn't that much, as you can see from the above list), the problem is users, not browsers. Until it's a safe bet that nearly all users are running the current crop of browsers, I don't feel comfortable relying on ES6 browser support. At some point, I'll either decide to flip the switch, or add a small loader that detects your browser's capabilities and then loads the appropriate compiled code.

More PDP-11 Boot Options

PDP-11 machines no longer need to be running the PDP-11 Boot Monitor in order to boot from disk images. Disk Controllers can now (and do) include Boot buttons that simulate reading and executing the selected disk's boot sector. Note that the disk image must be loaded with the Load button first (unless it was preloaded by the machine configuration).

We use the same terminology for Paper Tape controls now, too. Tapes are "Loaded" into the Paper Tape reader in the same way that disk images are "Loaded" into their respective drives. Yes, SimH uses the term "Attach", but PCjs machines have always used the "Load" to describe this operation, so we're going to stick with that. Also, the control to read a Paper Tape image directly into memory is now called Read.

A number of other features crept into this release as well, including some Debugger improvements, such as the ability to:

• Set read/write breakpoints on IOPAGE addresses
• Refer to IOPAGE addresses by their symbolic name, if any (eg, RBUF, XCSR, etc)

And there were some performance improvements, such as:

• Eliminating the NO_FLAGS hack (PSW flags are simply updated before the destination)
• Combining DEBUGGER checks with OPFLAG checks, so all we have to check is opFlags

PDP-11 support for RSTS/E

This release includes all the necessary support for booting RSTS/E on a PDP-11/70.

PDP-11 support for RK03 and RT-11

PDPjs now supports RK03 disk images and can run RT-11.

It also passes most of the DEC diagnostics that I've tried so far.

Give it a spin using this PDP-11/70 with 256Kb and VT100 terminal.

Vote for the PDP-11!

Greetings from an alternate reality where DEC's elegant PDP-11 architecture beat out Intel's gross 8086 architecture, and DEC managed to gracefully evolve the 16-bit PDP-11 into powerful 32-bit and 64-bit successors, all while maintaining excellent backward compatibility.

Unfortunately, you're stuck in your reality, so you have no idea what I'm talking about. Basically, your ancestors voted for the cheapest solution rather than the best solution, and now you have to live with the consequences.

The good news: PDPjs makes it possible for you to go back in time, and for a moment at least, and relive the PDP-11 experience. It's still a somewhat primitive experience, but PDPjs is a work-in-progress, so hang in there.

This latest release adds the following features:

• Functional Front Panels
• ROMs such as DEC's M9312 ROMs can now be installed
• Support for DEC's RL11 Disk Controller has been implemented

You can test RL11 support in this machine. Select the "XXDP+ Diagnostics" disk from the "Disk Drive Controls", click "Load", and wait for the message:

Mounted disk "XXDP Diagnostics" in drive RL0

Then start the machine (click "Run") and make sure the following prompt has been displayed:

PDP-11 MONITOR V1.0

BOOT> 

At the prompt, type "BOOT RL0". The following text should appear:

CHMDLD0 XXDP+ DL MONITOR
BOOTED VIA UNIT 0
28K UNIBUS SYSTEM

ENTER DATE (DD-MMM-YY): 

RESTART ADDR: 152010
THIS IS XXDP+.  TYPE "H" OR "H/L" FOR HELP.

.

And that's the extent of my testing, so if you try anything else and it doesn't work, feel free to open an issue.

Better yet, fork the PCjs Project, debug the problem yourself, test a fix, and then send me a pull request. :-)

Finally, another shout-out to Paul Nankervis, who not only generously gave permission to use code from his JavaScript PDP 11/70 Emulator (v1.4), but has also patiently answered my many questions.

I'm @jeffpar and I approve this release.

Booting PDP-11 BASIC in PDPjs

PDPjs can now simulate a PDP-11/20. It was one of the first PDP-11 models, and since it had no MMU, it was limited to a maximum of 56Kb of RAM (or as DEC would say, 28K words), since the top 8Kb (or 4K words) of its 16-bit address space was reserved for UNIBUS devices.

The first PDPjs test of a PDP-11/20 configuration was attempting to run PDP-11 BASIC, by loading it directly into memory from the original paper tape image. This required changes to the RAM component, including a new loadImage() interface that understands DEC's paper tape format.

To provide a more "authentic" experience, there is also a new PC11 Paper Tape component, and machines can now be configured to include a virtual paper tape reader, with an assortment of paper tapes ready to be attached.

In the real world, before you could load any paper tape, you had to first enter a Bootstrap Loader. PDPjs has simplified that process by including the Bootstrap Loader as just another paper tape image that you can "Load" directly into memory. Once that has been loaded, you can then read any other paper tape image, once you "Attach" it to the paper tape reader.

PDPjs and support for the PDP-11

PDPjs is the newest addition to the PCjs family of emulators, which includes PCx86, PC8080, and C1Pjs.

While PDPjs may eventually support a range of DEC PDP machines, current focus is on the PDP-11, starting with the PDP-11/70. From there, I'll work backwards to support other PDP-11 models, such as the PDP-11/45, until I reach the beginning of the PDP-11 line: the PDP-11/20.

I'm starting with the top-of-the-line PDP-11/70 largely because the core of the emulator is being adapted from the JavaScript PDP 11/70 Emulator (v1.3) written by Paul Nankervis, who has generously given permission to use his code in PCjs. Since his emulator is a fully functional 11/70, it made sense to start there and work backwards, neutering features as needed.

The code has already undergone a lot of refactoring. Opcodes are now decoded by function table rather than one gigantic switch statement, and every opcode is implemented with a discrete function. Other refactoring includes flag management, interrupt management, and device management.

Most of the work remaining is in device management. Like other PCjs emulators, PDPjs now has a Bus component, bus.js, that allows separate device components to register I/O handlers for specific UNIBUS addresses. During the initial port, I moved all of Paul's original device management code into one "catch-all" component, device.js, which must now be converted to the new I/O registration model.

The first new device component is serialport.js, which is currently the only means PDPjs has of communicating with the outside world. So you can try PDPjs connected to a VT100 Terminal, by clicking the "Run" button on the test machine. The test machine is running custom boot code written by Paul, but due to the lack of other device support, nothing can be booted yet.

Obviously PDPjs is very much a work-in-progress. Before I proceed much farther, I really want to put the CPU through some rigorous testing, so I'll be on the lookout for some comprehensive PDP-11 instruction tests. Or I'll write my own, and compare results across 1 or 2 other PDP-11 emulators.

PC8080 Improvements for the VT100

This release includes a few VT100 improvements in the PC8080 emulator:

• NVRAM defaults to factory settings, with two exceptions: ONLINE (ON) and ANSI (ON)
• Simulated correct clocking of the keyboard UART, ensuring accurate cursor blink rate
• Optimized the CPU run loop, using the CPU's new timer services to drive video updates
• Disabled the test screen in the VT100's Video powerUp() handler, now that everything's working

That's about it. Future VT100 work will, uh, occur in the future, and will probably start with AVO support (ie, more video RAM, so that more attributes and more lines in 132-column mode are available).