# Operation Guide

There are two ways to run the Elliott 803 simulator:

- Interactive Graphical Interface
  - Start Up and Shut Down
  - The Simulation Control Window
    - Controlling the Simulation Speed
    - Loading and Saving Machine Images
  - The Operator Console
  - The CPU and Core Store
    - Performance Note
  - The Output Teletype
  - The Graph Plotter
  - The Paper Tape Readers and Punches
    - Tape Formats
  - Sound Output
    - Performance Note
- Command Line Interface

Most people will want to use the Graphical interface.

Some further details of how programs are loaded and run are given here:

- Loading Programs

## Interactive Graphical Interface

The graphical interface can be started by running the simulator JAR file or by running the `elliott803.Main` program within the JAR.

### Command

>        java -jar elliott803-n.n.n.jar [options] [machine]
>     or java elliott803.Main [options] [machine]

#### Parameters

> `machine`
>   A previously saved machine image.

#### Options

> `-volume volume`
>   The initial loudspeaker volume. This should be a number from 0 to 10, a value of 0 will switch the sound emulation off (which can be useful on slower machines). If not specified the default value is 5.
> `-look lookandfeel`
>   The name of the Java look-and-feel to use. By default the standard platform look-and-feel will be used. Other look-and-feels that may be available (depending on operating system and Java version) include: `metal`, `ocean`, `steel`, `windows`, `classic`, `motif`, `gtk`, `mac` and `nimbus`.

The graphical interface displays a main window containing several smaller internal windows representing the various hardware and devices that form the Elliott 803 simulation. These windows can be moved around and resized (or minimized) as required. The current layout can be saved as part of a machine image and restored in a later run.

Most interaction will take place with the paper tape reader and tape punch devices and with the system operator's console.

### Start Up and Shut Down

When the simulator starts up it can load a pre-saved machine image containing the complete core memory contents and the size, position any layout of all the application windows. This image can either be provided as a parameter when starting the application or can be loaded later. If no image is provided a default window layout will be used.

### The Simulation Control Window

The simulation control window provides functions not present on a real 803 that are used to perform additional control of the simulation. The two additional functions provided are for controlling the simulation speed and for loading and saving machine images.

#### Controlling the Simulation Speed

The CPU Speed section is used to control and display the simulated CPU speed. The speed can be set to Real time which should run at a very close approximation to the speed of a real 803B or, if the checkbox is cleared, it can be set to run as fast as the implementation will allow. Note that sound can only be produced when the speed is set to real time.

The CPU speed number displays the current simulation speed in relation to real machine - so 1.0 means it is running at the same speed as a real machine (which should be the case when the Real time option is selected) and values greater than 1 indicate running faster than a real machine.

#### Loading and Saving Machine Images

The Machine Image section is used to save the current machine image or restore a previously saved machine image. A machine image consists of the complete core memory and may also include the size, position and layout of all the windows on the screen. They are typically saved as files with an extension of "`.803`".

### The Operator Console

The operator console is the mechanism by which the computer is operated. There are 39 buttons on the left hand side called the Word Generator. These buttons are used to form complete machine words, typically instructions. For convenience the value of the instruction currently formed by the buttons on the word generator is shown at the bottom of the window.

Note: When one of these 39 buttons is pressed it will stay pressed down. You can release the button, and all other buttons in the same group, by pressing the red release button (marked with an R) at the far left of the row.

On the right hand side are the various operation buttons and indicator lights. The Clear Store button sets all storage locations to zero. The Reset button stops any current execution, clears any "busy" condition and returns control to the console.

The three buttons marked Read, Normal and Obey are used in conjunction with the Operate bar to operate the computer. To use them you first select the function required by pressing one of the three buttons then hit the Operate bar to execute it.

The Read function reads the instruction currently set on the word generator buttons to the CPU instruction register, ready to be executed. The Obey function obeys the next instruction then returns to step-by-step mode. The Normal function obeys the next instruction and continues executing instructions normally.

So a typical sequence of operations to cause a jump to the initial instructions at location zero (to load a program from the tape reader) would be:

- Set the instruction 40 0 : 00 0 on the word generator (this just needs the top left-most button pressed).
- Select Read, Operate to load up that 40 0 instruction ready to be run.
- Select Normal, Operate to run the jump instruction and to continue running normally.

The Manual Data is used to cause the system to wait (until the Operate bar is pressed) whenever an instruction to read the word generator is executed. If this button is not pressed the word generator value will be read without any pause.

The indicator lights show the following conditions:

- Parity
  a parity error has been detected in the core store - this cannot happen in the simulator.
- Block Transfer
  a data transfer is happening to or from a device - this will flicker on and off when reading or writing tapes for example.
- Busy
  the system is waiting for input or output - typically waiting for a tape to loaded in a tape reader or punch.
- Floating Point Overflow
  a floating point operation has overflowed - execution stops if this occurs and will only continue when the Operate bar is pressed.
- Step by Step
  the system is stopped waiting for operator action - this is the condition on start up, after the Reset key is pressed or if the Read or Obey buttons are selected.
- Overflow
  the overflow condition is set - this will usually flicker on and off as programs are loaded or run.

The Volume slider controls the level of the sounds produced by the console speaker. Setting the volume to 0 will switch off all sounds.

This window is supposed to look and operate somewhat like the real Elliott 803 operator console.

### The CPU and Core Store

The CPU window shows the values of some of the important internal registers as execution proceeds. This includes the currently executing instruction and the contents of the accumulator and auxiliary registers. When running in step-by-step mode the CPU window will display the next instruction that is about to be executed.

At the bottom of the window are two debug options: Pressing the Dump button will produce a system core dump. This can be formatted and displayed using the Core File Formatter utility. Selecting the Trace option will turn on and off the system instruction trace. This can be formatted and displayed using the Trace File Formatter utility.

The core store window shows a view of the 8K words of store. It is intended to give a rough idea of where in store work is taking place.

The window shows 128 lines of 64 small blocks, each block representing a single word of store. The block will be white if the word of store contains zero, otherwise it will alternate between light and dark grey whenever a value is written to the storage location.

#### Important Performance Note

When running in real time mode the the simulation will operate at a very close approximation to the speed of a real Elliott 803B - this can be quite slow compared to modern machines especially when reading tapes or printing output (the teletype operates at about 10 characters per second).

If real time mode is deselected the simulation will simply run as fast as possible, however the frequent updates to the CPU and Core Store windows that take place as execution proceeds considerably slow down the speed of the emulation. If you want processing to run at a much faster speed one or both of these windows should be minimized.

### The Output Teletype

The output teletype shows the printed output from the computer. The data will scroll up as new lines are output or when the Scroll button is pressed.

To save output from the teletype press the Save... button and set a log file to store the output. New output will be appended to the end of any existing log file. The log file will be closed if the Clear button is pressed and this will also clear any current teletype output.

When selecting a log file you will need to choose an appropriate tape format for the resulting log file.

### The Graph Plotter

The graph plotter displays any plotter output generated. The output is scaled so that the current width of the plotter window represents the full width of a real Calcomp plotter, that is 11 inches.

Pressing the Clear button will clear the plotter output and reset the pen to the left hand edge. Take care pressing Clear as the image cannot be recovered without re-running the program that generated it.

### The Paper Tape Readers and Punches

The paper tape readers and paper tape punches are the primary means of input/output for the computer. "Tapes" are held as files on the host PC system and the Load and Save buttons on the tape devices produce a file selection dialog that allows the tape files to be selected.

When selecting a tape file you will need to choose an appropriate tape format for the file.

There are two lights on the tape devices to show their current status

- Busy will be illuminated if the device is reading or writing data. It will go out when the device is idle. This can be used to determine when, for example, a tape has finished loading.
- Waiting will be illuminated if the device has had a read or write operation issued against it but it has no tape loaded. The CPU will be in a busy wait until either a tape file is loaded into the device so operation can continue or the Reset key on the operators console is pressed.

#### Tape Formats

When reading or writing files using the tape readers and tape punches you need to consider the format of the tape file that is to be read or written. Tapes can be in Elliott format or in System format.

- Elliott format tapes are either binary program tapes or tapes whose characters are encoded as Elliott telecode.
- System tapes are text tapes (such as program source code or program data) that are encoded as normal text files on the PC.

The file selection dialogs contain a panel on the right hand side that allows the correct tape format to be selected. Depending on the action requested the tape format will offer one or more of the following options:

Auto
  The tape format will be automatically selected. This is the default format for the tape readers and is normally the correct one to choose. The contents of the file will be examined to determine if it is an Elliott binary or telecode tape or if it is a system text file.
Elliott
  The tape is in Elliott binary or telecode format. This is the default format for the tape punches, as it is assumed they may be writing binary data (such as compiler output tapes). If the output is text it will be encoded in telecode and can be converted to the system character set using the TapePrint utility.
System
  The tape is in standard system format. This is the default format for teleprinter output. This is only suitable for text input or output - the characters read or written to the tape will be automatically converted from or to telecode as necessary.
US-ASCII
  This option is only available with the System output format. It ensures that only characters from the US-ASCII character set are used when converting from telecode to system characters, in particular the GB pound sign character (`£`) will be written as the number sign (`#`).

### Sound Output

On a real 803 machine whenever the CPU executed certain instructions (any instruction from groups 4, 5, 6 or 7) a pulse would be sent to the loudspeaker in the operator console. In general this results in fairly random noise being generated as programs execute, although repeating sequences of instuctions or carefully chosen sets could create recognizable sounds. For example a jump instruction (a group 4 opcode) would produce a pulse, a jump to the location with the jump instruction would result in a tight spin loop with one pulse every 288us - which gives a steady tone of about 3.5kHz. See the music sample program for another example.

The simulation attempts to replicate these sounds using the PC sound card. The volume of sound produced can be controlled using the Volume slider on the Operator Console. Note that for sound to be produced the simulation must be set to be running in real time mode.

#### Important Performance Note

To generate accurate sounds a reasonably fast PC is needed. On a slower machine, particularly with a single core processor, it may be necessary to minimize the CPU and Core Store windows to improve sound output. If sound performance still seems break up or stutter, it is probably best to turn the sound off by setting the volume slider to 0 or starting the program with the`-volume 0` parameter.

## Loading Programs

If you are patient, careful and very meticulous it is possible to enter a complete program and run it using only the operator's console. If you want to try, here's a very simple two line program that will print a series of 'A's to the teletype:

>     128:  74 4127 : 74 4097          * Print a letter shift and a letter 'A'
>     129:  40  128 : 00    0          * Jump to location 128 to repeat

This could be entered and run using the following sequence of operations:

Word Generator | Operation | Notes
--- | --- | ---
Reset the computer ready for use
| Reset | The "Step by step" light should now be on.
Load the short program into store
`70 0 : 00 0` | Read, Operate | Put the instruction 70 0 (read the word generator to the accumulator) into the instruction register ready to be obeyed (but not run yet)
`74 4127 : 74 4097` | Obey, Operate | Obey the previous 70 0 instruction so the accumulator now contains the instruction 74 4127 : 74 4097 (Hint: 4127 = 4096 + 31, 4097 = 4096 + 1)
`20 128 : 00 0` | Read, Operate, Obey, Operate | Put the instruction 20 128 (store accumulator to location 128) into the instruction register and obey it.
`70 0 : 00 0` | Read, Operate | Get the 70 0 instruction ready to be obeyed again
`40 128 : 00 0` | Obey, Operate | Obey the previous instruction so the accumulator now contains 40 128 : 00 0
`20 129 : 00 0` | Read, Operate, Obey, Operate | Put the instruction 20 129 (store accumulator to location 129) into the instruction register and obey it.
Run the program
`40 128 : 00 0` | Read, Operate, Normal, Operate | Reads and executes a 40 128 (jump to location 128) instruction and continues running normally, i.e. fetching and executing instructions from store. The short program should run and print continuous 'A' characters to the output teletype.
Stop the program
| Reset | Output should stop and the system return to "Step by step" mode.

### Initial Instructions

Clearly this method of loading and running programs is impractical for any program of any size, so the 803 provides a better solution. Storage locations 0 through to 3 contain hard-wired instructions called the Initial Instructions, these are a bootstrap program that can load binary data from paper tape (in tape reader 1) into consecutive words in store. Since a word is 39 bits and each character on tape is 5 bits, it takes 8 tape characters for each word of store.

For interest, the initial instructions are these:

>     0:  26 4 : 06 0
>     1:  22 4 / 16 3
>     2:  55 5 : 71 0
>     3:  43 1 : 40 2

They use just one extra word (location 4) of working storage and can load the program into any location in store - the first word read from the tape defines the load address for the rest of the data. You might like to try to figure out how it works!

This means the standard way of loading a program is to put the program tape into the reader and execute a jump to location 0 to invoke the initial instructions.

## Command Line Interface

The simulator can also be run as a command line function, although this is probably less useful for most people.

### Command

>     java elliott803.Run [options] programtape [entryaddress]

#### Parameters

> `programtape`
>   The binary program tape to be loaded by the initial instructions.
> `entryaddress`
>   The program entry point address to jump to after the tape is loaded. This will be ignored for a self-triggering program tape.

#### Options

> `-reader1 inputtape`
>   The tape to load in reader 1 (after program tape is read).
> `-reader2 inputtape`
>   The tape to load in reader 2.
> `-punch1 outputtape`
>   The output tape file for punch 1
> `-punch2 outputtape`
>   The output tape file for punch 2
> `-teletype outputfile`
>   The output file for teletype, defaults to standard out
> `-wordgen "instruction"`
>   The value to set on the word generator, formatted as an instruction e.g. `"70 1 : 00 1"`.
> `-press keynumber`
>   A key to press if the system waits for keyboard input. The top-left key (the Function 1 "40" or sign bit) is keynumber 1, the bottom right key (the Address 2 "1" bit) is keynumber 39. Other typically useful keynumbers are 20 (the B-digit) and 21 (the Function 2 "40" bit).
> `-ascii`
>   Print using only US-ASCII characters
> `-dump`
>   Produce a system dump on exit
> `-trace`
>   Produce a full instruction trace

As an example the sample Character Set program can be run with this command. This will result in the telecode character set being printed to the terminal or command line session.

>     java elliott803.Run -ascii tapes/samples/charset.tape

#### Running ALGOL Programs from the Command Line

An ALGOL source program cannot be directly compiled and run using the command line interface, however it is possible use the graphical interface to compile a program and produce a dump tape of the compiled source and runtime. This dump tape can then be run from the command line.

To produce a dump tape start by loading the ALGOL compiler and compiling your program as described in Running ALGOL Programs. Proceed up to step 3 of the Compiling and Running a Program section. At this point, instead of running the program, press the Reset button and execute a 40 12 instruction from the console. The system will then write the dump tape of the compiled program to Punch 1.

The resulting tape is in a form that can loaded and run directly without needing the ALGOL compiler, so it can be run using the command line interface. After loading the tape the system will enter a Data Wait, so a command line option of`-press 21` is needed to cause it to execute.

As an example the Trigonometric Table ALGOL program has been compiled to a sample dump tape and can be run with this command.

>     java elliott803.Run -press 21 tapes/samples/trig.dump.tape

The program will end in a spin loop, you will need to press Ctrl-C to end the process.

Tim Baldwin December 2013 tjb803@tinymail.co.uk | Return to index © Tim Baldwin 2009,2013