+
+
+
+
+
+
+
+
+
+ 
+
+
+
+
+
\ No newline at end of file
diff --git a/webUI/B220MagTapeDrive.js b/webUI/B220MagTapeDrive.js
new file mode 100644
index 0000000..b884352
--- /dev/null
+++ b/webUI/B220MagTapeDrive.js
@@ -0,0 +1,1899 @@
+/***********************************************************************
+* retro-220/webUI B220MagTapeDrive.js
+************************************************************************
+* Copyright (c) 2017, Paul Kimpel.
+* Licensed under the MIT License, see
+* http://www.opensource.org/licenses/mit-license.php
+************************************************************************
+* Burroughs 220 Magnetic Tape Drive Peripheral Unit module.
+*
+* Defines a magnetic tape drive peripheral unit type, emulating the
+* 220 Tape Storage Unit at 208.333 bits/inch and 120 inches/sec.
+*
+* Internally, tape images are maintained as a two-dimensional array of 64-bit
+* floating-point words, similar to Javascript Number objects. The first dimension
+* represents lanes on the tape; the second represents words in tape blocks.
+*
+* Blocks are formatted internally in a manner similar to their physical layout
+* on tape, as follows. This scheme was chosen to allow reasonable behavior after
+* a lane change with an MLS command:
+*
+* * The tape begins with 2083 words of flaw markers (-4 words, see below).
+* This represents the magnetic beginning-of-tape area written to
+* newly-edited tape.
+*
+* * Tape words are stored as non-negative floating-point values having 11 BCD
+* digits (44 bits) each. The high-order digit is the 220 sign.
+*
+* * Negative word values are used to designate special control words in the
+* tape image:
+* -1 Blank (erased) tape/inter-block gap words
+* -2 End-of-block and erase-gap words
+* -3 Magnetic end-of-tape words
+* -4 Flaw markers and magnetic beginning-of-tape words
+*
+* * A block begins with three inter-block gap (-1) words, followed by the
+* preface word. The preface word contains the length of the block in BINARY,
+* not BCD. Maximum valid value of a preface word is 100 (not zero). A preface
+* value of one indicates an end-of-tape block, although the block will
+* contain 10 words, the first of which is the EOT control word. Values 0 and
+* 2-9 are invalid block sizes.
+*
+* * Following the preface word are the data words for the block. In the case
+* of an end-of-tape block, the first word will be the EOT control word; the
+* remaining nine words will be zeroes.
+*
+* * Following the data words for the block will be two end-of-block/erase-gap
+* (-2) words. The inter-block gap words for the next block (or magnetic
+* end-of-tape or flaw marker words) begin immediately after these two words.
+*
+* * The tape ends with 2916 words of magnetic end-of-tape (-3) words. This
+* represents the magnetic end-of-tape area written to newly-edited tape.
+*
+* External tape images are ordinary text files in comma-separated variable (CSV)
+* format. Each line in the file represents one block for one lane. Each field
+* on the line represents one word for the tape image. The first field on the
+* line represents the lane number -- only its low-order bit is significant (0/1).
+* The second field is the preface word indicating the length of the data. A
+* block length of 100 is represented as either 0 or 100. Values greater than 100
+* or less than zero will be treated as 100.
+*
+* Note that with this representation, it is possible that the count in the
+* preface may not match the actual number of words on the rest of the line.
+* While this might be useful at some point to allow construction of invalid
+* tape blocks that generate Tape Preface Failure (TPF) halts, at present the
+* block is stored in the internal tape image with exactly the number of words
+* specified by the preface. The remaining words on the line will be truncated
+* or padded with zero words as necessary in the internal image to achieve this
+* block length.
+*
+* Also note that the arrangement of blocks with respect to their lane is
+* arbitrary. Blocks for a lane can be arranged on the external image separately
+* or intermingled with the blocks for the other lane. When exporting a tape
+* image that has been modified, the drive will always dump all of lane 0 and
+* then all of lane 1. To save space in the external image, trailing words of
+* zeroes will be trimmed from each block. The lane number and preface word will
+* written, however.
+*
+************************************************************************
+* 2017-07-09 P.Kimpel
+* Original version, from retro-205 D205MagTapeDrive.js.
+***********************************************************************/
+"use strict";
+
+/**************************************/
+function B220MagTapeDrive(mnemonic, unitIndex, config) {
+ /* Constructor for the MagTapeDrive object */
+ var y = ((mnemonic.charCodeAt(2) - "A".charCodeAt(0))*32) + 304;
+
+ this.config = config; // System configuration object
+ this.mnemonic = mnemonic; // Unit mnemonic
+ this.unitIndex = unitIndex; // Internal unit number
+ this.unitDesignate = -1; // External unit number
+
+ this.timer = 0; // setCallback() token
+
+ this.remote = false; // Remote/Ready status
+ this.notWrite = false; // Not-Write status
+ this.rewindLock = false; // Rewind-Lock status
+ this.powerOn = false; // Transport power on/standby status
+
+ this.clear();
+
+ this.loadWindow = null; // handle for the tape loader window
+ this.reelBar = null; // handle for tape-full meter
+ this.reelIcon = null; // handle for the reel spinner
+
+ this.doc = null;
+ this.window = window.open("../webUI/B220MagTapeDrive.html", mnemonic,
+ "location=no,scrollbars=no,resizable,width=384,height=184,left=0,top=" + y);
+ this.window.addEventListener("load",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.tapeDriveOnload), false);
+}
+
+// this.tapeState enumerations
+B220MagTapeDrive.prototype.tapeUnloaded = 0;
+B220MagTapeDrive.prototype.tapeLocal = 1;
+B220MagTapeDrive.prototype.tapeRewinding = 2;
+B220MagTapeDrive.prototype.tapeRemote = 3;
+
+// Internal tape image control words
+B220MagTapeDrive.prototype.markerGap = -1;
+B220MagTapeDrive.prototype.markerEOB = -2;
+B220MagTapeDrive.prototype.markerMagEOT = -3;
+B220MagTapeDrive.prototype.markerFlaw = -4;
+
+B220MagTapeDrive.prototype.density = 208.333;
+ // bits/inch
+B220MagTapeDrive.prototype.tapeSpeed = 120/1000;
+ // tape motion speed [inches/ms]
+B220MagTapeDrive.prototype.inchesPerWord = 12/B220MagTapeDrive.prototype.density;
+B220MagTapeDrive.prototype.millisPerWord = B220MagTapeDrive.prototype.inchesPerWord/B220MagTapeDrive.prototype.tapeSpeed;
+B220MagTapeDrive.prototype.maxTapeInches = 3500*12;
+ // length of a standard reel of tape [inches]
+B220MagTapeDrive.prototype.maxTapeWords = Math.floor(B220MagTapeDrive.prototype.maxTapeInches*B220MagTapeDrive.prototype.density/12);
+ // max words on a tape (12 digits/word)
+B220MagTapeDrive.prototype.minBlockWords = 10;
+ // min words in a physical block
+B220MagTapeDrive.prototype.maxBlockWords = 100;
+ // max words in a physical block
+B220MagTapeDrive.prototype.magBOTWords = Math.floor(10*12*B220MagTapeDrive.prototype.density/12);
+ // number of words in the magnetic beginning-of-tape area
+B220MagTapeDrive.prototype.magEOTWords = Math.floor(14*12*B220MagTapeDrive.prototype.density/12);
+ // number of words in the magnetic end-of-tape area
+B220MagTapeDrive.prototype.startOfBlockWords = 4;
+ // inter-block tape gap + preface [words]
+B220MagTapeDrive.prototype.endOfBlockWords = 2;
+ // end-of-block + erase gap [words]
+B220MagTapeDrive.prototype.repositionWords = B220MagTapeDrive.prototype.endOfBlockWords + 2;
+ // number of words to reposition backwards after a turnaround
+B220MagTapeDrive.prototype.startTime = 3;
+ // tape start time [ms]
+B220MagTapeDrive.prototype.stopTime = 3;
+ // tape stop time [ms]
+B220MagTapeDrive.prototype.turnaroundTime = 5;
+ // tape turnaround time after a direction change [ms]
+B220MagTapeDrive.prototype.rewindSpeed = 0.120;
+ // rewind speed [inches/ms]
+B220MagTapeDrive.prototype.reelCircumference = 10*Math.PI;
+ // max circumference of tape [inches]
+B220MagTapeDrive.prototype.spinUpdateInterval = 15;
+ // milliseconds between reel icon angle updates
+B220MagTapeDrive.prototype.maxSpinAngle = 33;
+ // max angle to rotate reel image [degrees]
+
+
+/**************************************/
+B220MagTapeDrive.prototype.$$ = function $$(e) {
+ return this.doc.getElementById(e);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.clear = function clear() {
+ /* Initializes (and if necessary, creates) the reader unit state */
+
+ this.ready = false; // ready status
+ this.busy = false; // busy status
+
+ this.image = null; // tape drive "reel of tape"
+ this.imgIndex = 0; // current word index in tape image
+ this.imgLength = 0; // tape image max length [words] to physical EOT
+ this.imgTopWordNr = 0; // highest-written word index within image data
+ this.imgWritten = false; // tape image has been modified (implies writable)
+
+ this.atBOT = true; // true if tape at physical beginning-of-tape
+ this.atEOT = false; // true if tape at physical end-of-tape
+ this.laneNr = 0; // currently selected lane number
+ this.reelAngle = 0; // current rotation angle of reel image [degrees]
+ this.tapeInches = 0; // current distance up-tape [inches]
+ this.tapeState = this.tapeUnloaded; // tape drive state
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.nil = function nil() {
+ /* An empty function that just returns */
+
+ return;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.releaseUnit = function releaseUnit(releaseControl, alarm) {
+ /* Releases the busy status of the unit. Typically used as a timed call-
+ back to simulate the amount of time the unit is busy with an I/O */
+
+ this.busy = false;
+ this.designatedLamp.set(0);
+ if (releaseControl) {
+ releaseControl(alarm);
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.setUnitDesignate = function setUnitDesignate(index) {
+ /* Sets this.unitDesignate from the UNIT DESIGNATE list selectedIndex value */
+
+ if (index <= 0) {
+ this.unitDesignate = -1;
+ this.remote = false;
+ this.setTapeReady(false);
+ } else {
+ if (index < 10) {
+ this.unitDesignate = index; // units 1-9
+ } else {
+ this.unitDesignate = 0; // unit 10
+ }
+ this.remote = true;
+ this.setTapeReady(true);
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.spinReel = function spinReel(inches) {
+ /* Rotates the reel image icon an appropriate amount based on the "inches"
+ of tape to be moved. The rotation is limited to this.maxSpinAngle degrees
+ in either direction so that movement remains apparent to the viewer */
+ var circumference = this.reelCircumference*(1 - this.tapeInches/this.maxTapeInches/2);
+ var degrees = inches/circumference*360;
+
+ if (degrees > this.maxSpinAngle) {
+ degrees = this.maxSpinAngle;
+ } else if (degrees < -this.maxSpinAngle) {
+ degrees = -this.maxSpinAngle;
+ }
+
+ this.reelAngle = (this.reelAngle + degrees)%360;
+ this.reelIcon.style.transform = "rotate(" + this.reelAngle.toFixed(0) + "deg)";
+
+ this.tapeInches += inches;
+ if (this.tapeInches < this.maxTapeInches) {
+ this.reelBar.value = this.maxTapeInches - this.tapeInches;
+ } else {
+ this.reelBar.value = 0;
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.moveTape = function moveTape(inches, delay, successor) {
+ /* Delays the I/O during tape motion, during which it animates the reel image
+ icon. At the completion of the "delay" time in milliseconds, "successor" is
+ called with no parameters. */
+ var delayLeft = Math.abs(delay); // milliseconds left to delay
+ var direction = (inches < 0 ? -1 : 1);
+ var inchesLeft = inches; // inches left to move tape
+ var lastStamp = performance.now(); // last timestamp for spinDelay
+
+ function spinFinish() {
+ this.timer = 0;
+ if (inchesLeft != 0) {
+ this.spinReel(inchesLeft);
+ }
+ successor.call(this);
+ }
+
+ function spinDelay() {
+ var motion;
+ var stamp = performance.now();
+ var interval = stamp - lastStamp;
+
+ if (interval <= 0) {
+ interval = this.spinUpdateInterval/2;
+ if (interval > delayLeft) {
+ interval = delayLeft;
+ }
+ }
+
+ if ((delayLeft -= interval) > this.spinUpdateInterval) {
+ lastStamp = stamp;
+ this.timer = setCallback(this.mnemonic, this, this.spinUpdateInterval, spinDelay);
+ } else {
+ this.timer = setCallback(this.mnemonic, this, delayLeft, spinFinish);
+ }
+ motion = inches*interval/delay;
+ if (inchesLeft*direction <= 0) { // inchesLeft crossed zero
+ motion = inchesLeft = 0;
+ } else if (motion*direction <= inchesLeft*direction) {
+ inchesLeft -= motion;
+ } else {
+ motion = inchesLeft;
+ inchesLeft = 0;
+ }
+
+ this.spinReel(motion);
+ }
+
+ spinDelay.call(this);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.setAtBOT = function setAtBOT(atBOT) {
+ /* Controls the at-Beginning-of-Tape state of the tape drive */
+
+ if (atBOT ^ this.atBOT) {
+ this.atBOT = atBOT;
+ if (!atBOT) {
+ B220Util.removeClass(this.$$("MTAtBOTLight"), "annunciatorLit");
+ } else {
+ this.imgIndex = 0;
+ this.tapeInches = 0;
+ this.reelAngle = 0;
+ B220Util.addClass(this.$$("MTAtBOTLight"), "annunciatorLit");
+ this.reelBar.value = this.maxTapeInches;
+ this.reelIcon.style.transform = "none";
+ }
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.setAtEOT = function setAtEOT(atEOT) {
+ /* Controls the at-End-of-Tape state of the tape drive */
+
+ if (atEOT ^ this.atEOT) {
+ this.atEOT = atEOT;
+ if (!atEOT) {
+ B220Util.removeClass(this.$$("MTAtEOTLight"), "annunciatorLit");
+ } else {
+ B220Util.addClass(this.$$("MTAtEOTLight"), "annunciatorLit");
+ this.reelBar.value = 0;
+ }
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.setTapeReady = function setTapeReady(makeReady) {
+ /* Controls the ready-state of the tape drive */
+ var enabled = (this.tapeState != this.tapeUnloaded) && !this.rewindLock &&
+ (this.tapeState != this.tapeRewinding && this.powerOn);
+
+ this.ready = this.remote & makeReady && enabled;
+ this.notReadyLamp.set(this.ready ? 0 : 1);
+ if (!this.ready) {
+ this.busy = false; // forced reset
+ this.designatedLamp.set(0);
+ }
+
+ if (enabled) {
+ if (this.remote) {
+ this.tapeState = this.tapeRemote;
+ } else {
+ this.busy = false; // forced reset
+ this.tapeState = this.tapeLocal;
+ }
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.setTapeUnloaded = function setTapeUnloaded() {
+ /* Controls the loaded/unloaded-state of the tape drive */
+
+ if (this.tapeState == this.tapeLocal && this.atBOT) {
+ this.tapeState = this.tapeUnloaded;
+ this.image = null; // release the tape image to GC
+ this.imgLength = 0;
+ this.imgTopWordNr = 0;
+ this.busy = false;
+ this.setTapeReady(false);
+ this.setAtBOT(false);
+ this.setAtEOT(false);
+ this.reelBar.value = 0;
+ this.reelIcon.style.visibility = "hidden";
+ this.$$("MTFileName").value = "";
+ B220Util.addClass(this.$$("MTUnloadedLight"), "annunciatorLit");
+ if (this.timer) {
+ clearCallback(this.timer);
+ this.timer = 0;
+ }
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.findBlockStart = function findBlockStart() {
+ /* Searches forward in the tape image on the currently-selected lane for the
+ start of a block or magnetic end-of-tape markers, or physical end-of-tape,
+ whichever occurs first. If an inter-block (blank) gap word is found, skips
+ over all of them and reads the preface word. Returns the preface word, or
+ the magnetic EOT marker (-3) word, or if physical EOT is encountered, an
+ inter-block gap (-1) word */
+ var imgLength = this.imgLength; // physical end of tape index
+ var lane = this.image[this.laneNr]; // image data for current lane
+ var result = this.markerGap; // function result
+ var state = 1; // FSA state variable
+ var w; // current image word
+ var x = this.imgIndex; // lane image word index
+
+ while (x < imgLength) {
+ w = lane[x++];
+ switch (state) {
+ case 1: // search for inter-block gap word
+ if (w == this.markerGap) {
+ state = 2;
+ } else if (w == this.markerMagEOT) {
+ result = w; // return the EOT word
+ this.imgIndex = x-1; // point to EOT word
+ x = imgLength; // kill the loop
+ }
+ break;
+
+ case 2: // search for preface word
+ if (w >= 0) {
+ result = w; // found preface, return it
+ this.imgIndex = x; // point to first data word in block
+ x = imgLength; // kill the loop
+ } else if (w != this.markerGap) {
+ result = w; // return whatever marker word was found
+ this.imgIndex = x-1; // point to the word found
+ x = imgLength; // kill the loop
+ }
+ break;
+
+ default:
+ x = imgLength; // kill the loop
+ throw new Error("Invalid state: B220MagTapeDrive.findBlockStart, " + state);
+ break;
+ } // switch state
+ } // while x
+
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.writeBlockStart = function writeBlockStart(length) {
+ /* Writes the start-of-block words to the tape image buffer in the current
+ lane number and at the current offset of this.imgIndex: 3 gap words + the
+ preface word with the binary block length */
+ var x;
+
+ for (x=0; xRWL
+
+ NOT WRITE
+
+ NOT READY
+
+ UNIT
DESIGNATE
+
+ DESIGNATE
TRANSPORT POWER
+
+ ON
+
+ STANDBY
+
+ LOAD
+
+ UNLOAD
+
+ REWIND
+
+
+ UNIT DESIGNATE
+
+ RWLR
+
+ WRITE
+
+ NOT WRITE
+
+ ON
+
+ ST'DBY
+
+
+
+ UNLOADED
+ AT BOT
+ AT EOT
+ REWINDING
+
+
+
+
++
content
+ tape.removeChild(tape.firstChild);
+ }
+
+ for (lx=0; lx<2; ++lx) {
+ mt.laneNr = lx;
+ lane = mt.image[lx];
+ state = 1;
+ x = 0;
+ while (x < imgLength) {
+ switch (state) {
+ case 1: // Search for start of block
+ nzw = 0;
+ mt.imgIndex = x;
+ w = mt.findBlockStart();
+ if (w < 0) { // done with this lane
+ x = imgLength; // kill the loop
+ } else { // format the preface word
+ buf = lx.toString(10) + "," + w.toString(10);
+ x = mt.imgIndex;
+ state = 2;
+ }
+ break;
+ case 2: // Record the block data words
+ w = lane[x++];
+ if (w == 0) {
+ ++nzw; // suppress trailing zero words
+ } else if (w >= 0) {
+ while (nzw > 0) {
+ --nzw; // restore non-trailing zero words
+ buf += ",0";
+ }
+ buf += "," + w.toString(16);
+ } else {
+ tape.appendChild(doc.createTextNode(buf + "\n"));
+ state = 1; // reset for next block
+ }
+ break;
+ default:
+ x = imgLength; // kill the loop
+ throw new Error("Invalid state: B220MagTapeDrive.unloadTape, " + state);
+ break;
+ } // switch state
+ } // while not at end of lane
+ } // for lx
+
+ mt.setTapeUnloaded();
+ }
+
+ function unloadSetup() {
+ /* Loads a status message into the "paper" rendering area, then calls
+ unloadDriver after a short wait to allow the message to appear */
+
+ win.document.getElementById("Paper").appendChild(
+ win.document.createTextNode("Rendering tape image... please wait..."));
+ setTimeout(unloadDriver, 50);
+ }
+
+ // Outer block of unloadTape
+ win.moveTo((screen.availWidth-win.outerWidth)/2, (screen.availHeight-win.outerHeight)/2);
+ win.focus();
+ win.addEventListener("load", unloadSetup, false);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.tapeRewind = function tapeRewind(laneNr, lockout, unitFinished) {
+ /* Rewinds the tape. Makes the drive not-ready and delays for an appropriate
+ amount of time depending on how far up-tape we are. Readies the unit again
+ when the rewind is complete unless lockout is truthy */
+ var lastStamp;
+
+ function rewindFinish() {
+ this.timer = 0;
+ this.tapeState = this.tapeLocal;
+ B220Util.removeClass(this.$$("MTRewindingLight"), "annunciatorLit");
+ this.laneNr = laneNr%2;
+ this.rewindLock = (lockout ? true : false);
+ this.rwlLamp.set(this.rewindLock ? 1 : 0);
+ this.setTapeReady(!this.rewindLock);
+ this.releaseUnit(unitFinished, false);
+ }
+
+ function rewindDelay() {
+ var inches;
+ var stamp = performance.now();
+ var interval = stamp - lastStamp;
+
+ if (interval <= 0) {
+ interval = this.spinUpdateInterval/2;
+ }
+ if (this.tapeInches <= 0) {
+ this.setAtBOT(true);
+ this.timer = setCallback(this.mnemonic, this, 1000, rewindFinish);
+ } else {
+ inches = interval*this.rewindSpeed;
+ lastStamp = stamp;
+ this.timer = setCallback(this.mnemonic, this, this.spinUpdateInterval, rewindDelay);
+ this.spinReel(-inches);
+ }
+ }
+
+ function rewindStart() {
+ this.designatedLamp.set(0);
+ lastStamp = performance.now();
+ this.timer = setCallback(this.mnemonic, this, this.spinUpdateInterval, rewindDelay);
+ }
+
+ if (this.timer) {
+ clearCallback(this.timer);
+ this.timer = 0;
+ }
+ if (this.tapeState != this.tapeUnloaded && this.tapeState != this.tapeRewinding) {
+ this.busy = true;
+ this.tapeState = this.tapeRewinding;
+ this.setAtEOT(false);
+ B220Util.addClass(this.$$("MTRewindingLight"), "annunciatorLit");
+ this.timer = setCallback(this.mnemonic, this, 1000, rewindStart);
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.tapeReposition = function tapeReposition(successor) {
+ /* Reverses tape direction after a forward tape operation and repositions
+ the head two words from the end of the block just passed, giving room for
+ startup of the next forward operation. At completion, calls the successor
+ function, passing false.
+
+ A real 220 drive repositioned tape about 60 digits (five words) from the end
+ of the data portion of the block, but that was to allow for tape acceleration
+ of about 3ms, at which point it took about 2ms (50 digits, or just over four
+ words) to reach the end of the erase gap and start of the inter-block gap
+ for the next block. this.repositionWords is sized to approximate that 2ms
+ delay */
+
+ this.imgIndex -= this.repositionWords;
+ this.moveTape(-this.repositionWords*this.inchesPerWord, this.turnaroundTime, successor);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.LoadBtn_onclick = function LoadBtn_onclick(ev) {
+ /* Handle the click event for the LOAD button */
+
+ if (!this.busy && !this.powerOn && this.tapeState == this.tapeUnloaded) {
+ this.loadTape();
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.UnloadBtn_onclick = function UnloadBtn_onclick(ev) {
+ /* Handle the click event for the UNLOAD button */
+
+ if (!this.busy && this.atBOT && !this.powerOn && this.tapeState == this.tapeLocal) {
+ if (this.imgWritten && this.window.confirm(
+ "Do you want to save the tape image data?\n(CANCEL discards the image)")) {
+ this.unloadTape(); // it will do setTapeUnloaded() afterwards
+ } else {
+ this.setTapeUnloaded();
+ }
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.RewindBtn_onclick = function RewindBtn_onclick(ev) {
+ /* Handle the click event for the REWIND button */
+
+ if (!this.busy && !this.powerOn && this.tapeState != this.tapeUnloaded) {
+ this.tapeRewind(this.laneNr, this.rewindLock, null);
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.UnitDesignate_onchange = function UnitDesignate_onchange(ev) {
+ /* Handle the change event for the UNIT DESIGNATE select list */
+ var prefs = this.config.getNode("MagTape.units", this.unitIndex);
+ var sx = ev.target.selectedIndex;
+
+ this.setUnitDesignate(sx);
+ prefs.designate = sx;
+ this.setTapeReady(this.remote);
+ this.config.putNode("MagTape.units", prefs, this.unitIndex);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.RWLRBtn_onclick = function RWLRBtn_onclick(ev) {
+ /* Handle the click event for the RWLR (Rewind-Lock-Release) button */
+
+ this.rewindLock = false;
+ this.rwlLamp.set(0);
+ this.setTapeReady(true);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.WriteBtn_onclick = function WriteBtn_onclick(ev) {
+ /* Handle the click event for the WRITE and NOT WRITE buttons */
+
+ this.notWrite = (ev.target.id == "NotWriteBtn");
+ this.notWriteLamp.set(this.notWrite ? 1 : 0);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.TransportOnBtn_onclick = function TransportOnBtn_onclick(ev) {
+ /* Handle the click event for the TRANSPORT POWER ON and STANDBY buttons */
+
+ this.powerOn = (ev.target.id == "TransportOnBtn") && (this.tapeState != this.tapeUnloaded);
+ this.transportOnLamp.set(this.powerOn ? 1 : 0);
+ this.transportStandbyLamp.set(this.powerOn ? 0 : 1);
+ this.setTapeReady(this.powerOn);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.beforeUnload = function beforeUnload(ev) {
+ var msg = "Closing this window will make the device unusable.\n" +
+ "Suggest you stay on the page and minimize this window instead";
+
+ ev.preventDefault();
+ ev.returnValue = msg;
+ return msg;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.tapeDriveOnload = function tapeDriveOnload() {
+ /* Initializes the reader window and user interface */
+ var body;
+ var prefs = this.config.getNode("MagTape.units", this.unitIndex);
+
+ this.doc = this.window.document;
+ this.doc.title = "retro-220 Tape Drive " + this.mnemonic;
+
+ body = this.$$("MTDiv");
+ this.reelBar = this.$$("MTReelBar");
+ this.reelIcon = this.$$("MTReel");
+
+ this.rwlLamp = new ColoredLamp(body, null, null, "RWLLamp", "blueLamp lampCollar", "blueLit");
+ this.notWriteLamp = new ColoredLamp(body, null, null, "NotWriteLamp", "blueLamp lampCollar", "blueLit");
+ this.notReadyLamp = new ColoredLamp(body, null, null, "NotReadyLamp", "blueLamp lampCollar", "blueLit");
+ this.designatedLamp = new ColoredLamp(body, null, null, "DesignatedLamp", "blueLamp lampCollar", "blueLit");
+ this.transportOnLamp = new ColoredLamp(body, null, null, "TransportOnLamp", "blueLamp lampCollar", "blueLit");
+ this.transportStandbyLamp = new ColoredLamp(body, null, null, "TransportStandbyLamp", "blueLamp lampCollar", "blueLit");
+
+ this.transportStandbyLamp.set(1);
+
+ this.unitDesignateList = this.$$("UnitDesignate");
+ this.unitDesignateList.selectedIndex = prefs.designate;
+ this.setUnitDesignate(prefs.designate);
+
+ this.tapeState = this.tapeLocal; // setTapeUnloaded() requires it to be in local
+ this.atBOT = true; // and also at BOT
+ this.setTapeUnloaded();
+
+ this.window.addEventListener("beforeunload",
+ B220MagTapeDrive.prototype.beforeUnload, false);
+ this.$$("LoadBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.LoadBtn_onclick), false);
+ this.$$("UnloadBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.UnloadBtn_onclick), false);
+ this.$$("RewindBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.RewindBtn_onclick), false);
+ this.unitDesignateList.addEventListener("change",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.UnitDesignate_onchange), false);
+ this.$$("RWLRBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.RWLRBtn_onclick), false);
+ this.$$("WriteBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.WriteBtn_onclick), false);
+ this.$$("NotWriteBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.WriteBtn_onclick), false);
+ this.$$("TransportOnBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.TransportOnBtn_onclick), false);
+ this.$$("TransportStandbyBtn").addEventListener("click",
+ B220Util.bindMethod(this, B220MagTapeDrive.prototype.TransportOnBtn_onclick), false);
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.readBlock = function readBlock(receiveBlock) {
+ /* Reads the next block from the tape. If at EOT, makes the drive not ready
+ and terminates the read. After delaying for tape motion, calls the receiveBlock
+ callback function to pass the block to the control unit and thence the processor */
+ var wx = this.blockNr*this.blockWords;
+
+ if (this.blockNr >= this.imgLength) {
+ this.blockNr = this.imgLength;
+ this.setTapeReady(false);
+ this.setAtEOT(true);
+ this.designatedLamp.set(0);
+ this.busy = false;
+ receiveBlock(null, true); // terminate the I/O
+ } else {
+ if (this.atBOT) {
+ this.setAtBOT(false);
+ }
+ ++this.blockNr;
+ this.moveTape(this.blockLength, this.blockLength/this.tapeSpeed, function readBlockComplete() {
+ receiveBlock(this.image[this.laneNr].subarray(wx, wx+this.blockWords), false);
+ });
+ }
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.readTerminate = function readTerminate() {
+ /* Terminates a read operation on the tape drive and makes it not-busy */
+
+ this.designatedLamp.set(0);
+ this.busy = false;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.readInitiate = function readInitiate(receiveBlock) {
+ /* Initiates a read operation on the unit. If the drive is busy or not ready,
+ returns true. Otherwise, delays for the start-up time of the drive and calls
+ readBlock() to read the next block and send it to the Processor */
+ var result = false;
+
+ if (this.busy) {
+ result = true; // report unit busy
+ } else if (!this.ready) {
+ result = true; // report unit not ready
+ } else {
+ this.busy = true;
+ this.designatedLamp.set(1);
+ setCallback(this.mnemonic, this, this.startTime, this.readBlock, receiveBlock);
+ }
+ //console.log(this.mnemonic + " read: result=" + result.toString());
+
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.writeBlock = function writeBlock(block, sendBlock, lastBlock) {
+ /* Writes the next block to the tape. If at EOT, makes the drive not ready
+ and terminates the write. Calls the sendBlock callback function to request the
+ next block from the processor */
+ var lane = this.image[this.laneNr];
+ var wx = this.blockNr*this.blockWords;
+ var x;
+
+ if (this.blockNr >= this.imgLength) {
+ this.blockNr = this.imgLength;
+ this.setTapeReady(false);
+ this.setAtEOT(true);
+ this.designatedLamp.set(0);
+ this.busy = false;
+ sendBlock(true); // terminate the I/O
+ } else {
+ if (this.atBOT) {
+ this.setAtBOT(false);
+ }
+
+ // If the NOT WRITE switch is on, do not copy the block data to the tape image
+ if (!this.notWrite) {
+ this.imgWritten = true;
+ if (this.blockNr > this.imgTopWordNr) {
+ this.imgTopWordNr = this.blockNr;
+ }
+ for (x=0; x= this.imgLength) {
+ this.blockNr = this.imgLength;
+ this.setTapeReady(false);
+ this.setAtEOT(true);
+ }
+ complete(this.blockNr == targetBlock);
+ }
+
+ function searchBackward() {
+ /* While the tape is beyond the target block, moves backward one block and
+ is called by moveTape to evaluate the new block position */
+
+ --this.blockNr;
+ if (this.atEOT) {
+ this.setAtEOT(false);
+ }
+
+ if (testDisabled()) {
+ finishSearch.call(this);
+ } else if (this.blockNr > targetBlock) {
+ this.moveTape(-this.blockLength, delay, searchBackward);
+ } else {
+ finishSearch.call(this);
+ }
+ }
+
+ function searchForward() {
+ /* Searches forward until the tape is beyond the target block, then
+ reverses direction and does a backward search */
+
+ ++this.blockNr;
+ if (this.atBOT) {
+ this.setAtBOT(false);
+ }
+
+ if (testDisabled()) {
+ finishSearch.call(this);
+ } else if (this.blockNr >= this.imgLength) {
+ this.blockNr = this.imgLength;
+ finishSearch.call(this);
+ } else if (this.blockNr <= targetBlock) {
+ this.moveTape(this.blockLength, delay, searchForward);
+ } else {
+ // We have searched forward (or are already forward) of the target block.
+ // Now change direction and search backwards to the target.
+ lampSet(false); // indicate backward motion
+ this.moveTape(-this.blockLength, this.turnaroundTime, searchBackward);
+ }
+ }
+
+ if (this.busy) {
+ result = true; // report unit busy
+ } else if (!this.ready) {
+ result = true; // report unit not ready
+ } else {
+ this.busy = true;
+ this.laneNr = laneNr & 0x01; // TSU uses only low-order lane bit
+ this.designatedLamp.set(1);
+
+ // Begin by searching forward until we are past the target block
+ lampSet(true); // indicate forward motion
+ this.moveTape(this.blockLength, delay+this.startTime, searchForward);
+ }
+
+ //console.log(this.mnemonic + " search: result=" + result.toString());
+ if (result) {
+ complete(false);
+ }
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.initialWriteBlock = function initialWriteBlock(blockReady, controlFinished) {
+ /* Writes one block on edited (blank) tape. "blockReady" is a function
+ to be called after the block is written. "releaseControl" is a function
+ to call after the control signals completion (see release). This routine
+ is used for both MIW and MIR, as block lengths are determined by the
+ tape control unit */
+ var imgLength = this.imgLength; // physical end of tape index
+ var lane = this.image[this.laneNr]; // image data for current lane
+ var result = false;
+ var startIndex = this.imgIndex; // initial index into lane buffer
+ var that = this;
+
+ function release() {
+ /* Releases the unit and control */
+
+ that.releaseUnit(controlFinished, false);
+ }
+
+ function finish() {
+ /* Wraps up the positioning and delays before releasing the unit and control */
+ var delay = 20 - that.startTime - that.repositionTime;
+
+ setCallback(that.mnemonic, that, delay, release);
+ }
+
+ function turnaround() {
+ /* Repositions the tape after the last block is written */
+
+ that.tapeReposition(finish);
+ }
+
+ function finalizeWrite() {
+ /* Write a longer inter-block gap so that MPE will work at magnetic
+ end-of-tape, check for end-of-tape, and initiate repositioning prior
+ to terminating the I/O */
+ var count = that.startOfBlockWords*2; // number of gap words
+ var done = false; // loop control
+ var x = that.imgIndex; // lane image word index
+
+ do {
+ if (x >= imgLength) {
+ done = true; // at end-of-tape
+ that.setAtEOT(true);
+ advance.call(that, x, finish);
+ } else if (count > 0) {
+ --count; // write extra inter-block gap word
+ lane[x] = that.markerGap;
+ ++x;
+ } else if (lane[x] == that.markerMagEOT) {
+ ++x; // space over magnetic EOT words
+ } else {
+ done = true; // finish write and initiate repositioning
+ advance.call(that, x, turnaround);
+ }
+ } while(!done);
+ }
+
+ function finalizeBlock() {
+ /* Returns to the tape control after completion of one block */
+
+ blockReady(false, writeBlock, finalizeWrite);
+ }
+
+ function abort() {
+ /* Aborts the I/O due to some error */
+
+ blockReady(true, null, release);
+ }
+
+ function setEOT() {
+ /* Sets EOT status after positioning to end-of-tape. Does not release
+ the control unit */
+
+ that.setAtEOT(true);
+ that.releaseUnit(null, false);
+ }
+
+ function advance (index, successor) {
+ /* Advances the tape after a block is passed, then calls the successor */
+ var len = index - that.imgIndex; // number of words passed
+ var delay = len*that.millisPerWord; // amount of tape spin time
+
+ that.imgIndex = index;
+ if (index > that.imgTopWordNr) {
+ that.imgTopWordNr = index;
+ }
+ that.moveTape(len*that.inchesPerWord, delay, successor);
+ }
+
+ function writeBlock(block, words) {
+ /* Writes the next block from the words in "block" */
+ var count = 0; // word counter
+ var done = false; // completion flag
+ var gapCount = 0; // count of consecutive inter-block gap words
+ var state = 1; // FSA state variable
+ var x = that.imgIndex; // lane image word index
+
+ if (!that.ready) {
+ done = true;
+ advance.call(that, x, abort); // drive went non-ready
+ } else {
+ do {
+ if (x >= imgLength) {
+ done = true; // at EOT: just exit and leave everybody hanging...
+ that.busy = false;
+ advance.call(that, x, setEOT);
+ } else {
+ switch (state) {
+ case 1: // initial state: skip over flaw and intra-block words
+ if (lane[x] == that.markerGap) {
+ state = 2;
+ } else {
+ ++x;
+ }
+ break;
+ case 2: // count 3 consecutive inter-block gap words
+ if (lane[x] == that.markerGap) {
+ ++gapCount;
+ if (gapCount < that.startOfBlockWords) {
+ ++x;
+ } else {
+ state = 3;
+ }
+ } else if (lane[x] == that.markerMagEOT) {
+ ++x;
+ } else {
+ done = true;
+ that.imgIndex = x;
+ advance.call(that, x, abort); // not an edited tape
+ }
+ break;
+ case 3: // write the preface
+ lane[x] = words;
+ ++x;
+ state = 4;
+ break;
+ case 4: // write the block words
+ if (count < words) {
+ lane[x] = block[count];
+ ++x;
+ ++count;
+ } else if (count < that.minBlockWords) {
+ lane[x] = 0;
+ ++x;
+ ++count;
+ } else {
+ count = 0;
+ state = 5;
+ }
+ break;
+ case 5: // write the erase gap
+ if (count < that.endOfBlockWords) {
+ lane[x] = that.markerEOB;
+ ++x;
+ ++count;
+ } else {
+ done = true;
+ advance.call(that, x, finalizeBlock);
+ }
+ break;
+ } // switch state
+ }
+ } while (!done);
+ }
+ }
+
+ function firstBlock() {
+ /* Called after the startTime delay to signal the control unit we are
+ ready for the first block of data */
+
+ blockReady(false, writeBlock, release);
+ }
+
+ if (this.busy) {
+ result = true; // unit busy
+ } else if (!this.ready) {
+ result = true; // unit not ready
+ } else if (this.notWrite) {
+ result = true; // tape in not-write status
+ } else if (this.atEOT) {
+ result = true; // tape at EOT
+ } else {
+ this.busy = true;
+ this.imgWritten = true;
+ this.designatedLamp.set(1);
+ this.setAtBOT(false);
+
+ // Begin with a delay for start-up time
+ setCallback(this.mnemonic, this, this.startTime, firstBlock);
+ }
+
+ //console.log(this.mnemonic + " initialWriteBlock result=" + result.toString());
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.positionForward = function positionForward(blockFinished, releaseControl) {
+ /* Initiates the positioning of tape in a forward direction and spaces the
+ first block. "blockFinished" is a function to be called after the block is
+ spaced. "releaseControl" is a function to call after the last block is spaced
+ (see spaceForward and turnaround) */
+ var lane = this.image[this.laneNr]; // image data for current lane
+ var result = false;
+ var that = this;
+
+ function release() {
+ /* Releases the unit and control */
+
+ that.releaseUnit(releaseControl, false);
+ }
+
+ function finish() {
+ /* Wraps up the positioning and delays before releasing the unit and control */
+ var delay = 16 - that.startTime - that.repositionTime;
+
+ setCallback(that.mnemonic, that, delay, release);
+ }
+
+ function turnaround() {
+ /* Repositions the tape after the last block is spaced over */
+
+ that.tapeReposition(finish);
+ }
+
+ function setEOT() {
+ /* Sets EOT status after positioning to end-of-tape. Does not release
+ the control unit */
+
+ that.setAtEOT(true);
+ that.relaseUnit(null, false);
+ }
+
+ function advance (index, successor) {
+ /* Advances the tape after a block is passed, then calls the successor */
+ var len = index - that.imgIndex; // number of words passed
+ var delay = len*that.millisPerWord; // amount of tape spin time
+
+ that.imgIndex = index;
+ that.moveTape(len*that.inchesPerWord, delay, successor);
+ }
+
+ function spaceForward(blockFinished) {
+ /* Spaces over the next block */
+ var done = false; // completion flag
+ var imgLength = that.imgLength; // physical end of tape index
+ var state = 1; // FSA state variable
+ var w; // current image word
+ var x = that.imgIndex; // lane image word index
+
+ do {
+ if (x >= imgLength) {
+ done = true; // just exit and leave everybody hanging...
+ that.busy = false;
+ advance.call(that, x, setEOT);
+ } else if (!that.ready) {
+ done = true;
+ that.busy = false;
+ that.releaseUnit(releaseControl, true);
+ } else {
+ w = lane[x];
+ switch (state) {
+ case 1: // initial state: skip over flaw and intra-block words
+ if (w == that.markerGap) {
+ state = 2;
+ } else {
+ ++x;
+ }
+ break;
+ case 2: // skip inter-block gap words
+ if (w != that.markerGap) {
+ state = 3;
+ } else {
+ ++x;
+ }
+ break;
+ case 3: // search for end of block (next inter-block gap word)
+ if (w != that.markerGap) {
+ ++x;
+ } else {
+ done = true;
+ advance.call(that, x, function cb() {blockFinished(spaceForward, turnaround)});
+ }
+ break;
+ } // switch state
+ }
+ } while (!done);
+
+ }
+
+ if (this.busy) {
+ result = true; // unit busy
+ } else if (!this.ready) {
+ result = true; // unit not ready
+ } else if (this.atEOT) {
+ result = true; // tape at EOT, leave control hung
+ } else {
+ this.busy = true;
+ this.designatedLamp.set(1);
+ this.setAtBOT(false);
+
+ // Begin with a delay for start-up time
+ setCallback(this.mnemonic, this, this.startTime, spaceForward, blockFinished);
+ }
+
+ //console.log(this.mnemonic + " positionForward result=" + result.toString());
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.positionBackward = function positionBackward(blockFinished, releaseControl) {
+ /* Initiates the positioning of tape in a backward direction and spaces the
+ first block. "blockFinished" is a function to be called after the block is
+ spaced. "releaseControl" is a function to call after the last block is spaced
+ (see spaceBackward and finish) */
+ var lane = this.image[this.laneNr]; // image data for current lane
+ var result = false;
+ var that = this;
+
+ function release() {
+ /* Releases the unit and control */
+
+ that.releaseUnit(releaseControl, false);
+ }
+
+ function finish() {
+ /* Wraps up the positioning and delays before releasing the unit and control */
+ var delay = 6 - that.startTime;
+
+ setCallback(that.mnemonic, that, delay, release);
+ }
+
+ function setBOT() {
+ /* Sets BOT status after positioning to beginning-of-tape. Does not
+ release the control unit */
+
+ that.setAtBOT(true);
+ that.releaseUnit(null, false);
+ }
+
+ function advance (index, successor) {
+ /* Advances the tape after a block is passed, then calls the successor */
+ var len = index - that.imgIndex; // number of words passed
+ var delay = len*that.millisPerWord; // amount of tape spin time
+
+ that.imgIndex = index;
+ that.moveTape(len*that.inchesPerWord, delay, successor);
+ }
+
+ function spaceBackward(blockFinished) {
+ /* Spaces over the current or prior block until the inter-block gap */
+ var done = false; // completion flag
+ var imgLength = that.imgLength; // physical end of tape index
+ var state = 1; // FSA state variable
+ var w; // current image word
+ var x = that.imgIndex; // lane image word index
+
+ do {
+ if (x <= 0) {
+ done = true; // just exit and leave everybody hanging...
+ that.busy = false;
+ advance.call(that, x, setBOT);
+ } else if (!that.ready) {
+ done = true;
+ that.busy = false;
+ that.releaseUnit(releaseControl, true);
+ } else {
+ w = lane[x];
+ switch (state) {
+ case 1: // initial state: skip over flaw words
+ if (w == that.markerGap) {
+ state = 2;
+ } else if (w != that.markerFlaw) {
+ state = 3;
+ } else {
+ --x;
+ }
+ break;
+ case 2: // skip initial inter-block gap words
+ if (w != that.markerGap) {
+ state = 3;
+ } else {
+ --x;
+ }
+ break;
+ case 3: // search for start of block (first prior inter-block gap word)
+ if (w != that.markerGap) {
+ --x;
+ } else {
+ state = 4;
+ }
+ break;
+ case 4: // skip this block's inter-block gap words
+ if (w != that.markerGap) {
+ done = true;
+ x -= that.repositionWords; // position into end of prior block, as usual
+ advance.call(that, x, function cb() {blockFinished(spaceBackward, finish)});
+ } else {
+ --x;
+ }
+ break;
+ } // switch state
+ }
+ } while (!done);
+ }
+
+ if (this.busy) {
+ result = true; // unit busy
+ } else if (!this.ready) {
+ result = true; // unit not ready
+ } else if (this.atBOT) {
+ result = true; // tape at BOT, leave control hung
+ } else {
+ this.busy = true;
+ this.designatedLamp.set(1);
+ this.setAtEOT(false);
+
+ // Begin with a delay for start-up time
+ setCallback(this.mnemonic, this, this.startTime, spaceBackward, blockFinished);
+ }
+
+ //console.log(this.mnemonic + " positionBackward result=" + result.toString());
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.positionAtEnd = function positionAtEnd(releaseControl) {
+ /* Positions the tape to the end of recorded information (i.e., gap longer
+ and inter-block gap */
+ var lane = this.image[this.laneNr]; // image data for current lane
+ var result = false;
+ var that = this;
+
+ function release() {
+ /* Releases the unit and control */
+
+ that.releaseUnit(releaseControl, false);
+ }
+
+ function finish() {
+ /* Wraps up the positioning and delays before releasing the unit and control */
+ var delay = 23 - that.startTime - that.repositionTime;
+
+ setCallback(that.mnemonic, that, delay, release);
+ }
+
+ function turnaround() {
+ /* Repositions the tape after finding end-of-info */
+
+ that.tapeReposition(finish);
+ }
+
+ function setEOT() {
+ /* Sets EOT status after positioning to end-of-tape. Does not release
+ the control unit */
+
+ that.setAtEOT(true);
+ that.relaseUnit(null, false);
+ }
+
+ function advance (index, successor) {
+ /* Advances the tape after a block is passed, then calls the successor */
+ var len = index - that.imgIndex; // number of words passed
+ var delay = len*that.millisPerWord; // amount of tape spin time
+
+ that.imgIndex = index;
+ that.moveTape(len*that.inchesPerWord, delay, successor);
+ }
+
+ function spaceForward() {
+ /* Spaces over the next block, unless a long gap or physical EOT is
+ encountered */
+ var done = false; // completion flag
+ var gapCount = 0; // number of consecutive erase-gap words
+ var imgLength = that.imgLength; // physical end of tape index
+ var state = 1; // FSA state variable
+ var w; // current image word
+ var x = that.imgIndex; // lane image word index
+
+ do {
+ if (x >= imgLength) {
+ done = true; // just exit and leave everybody hanging...
+ that.busy = false;
+ advance.call(that, x, setEOT);
+ } else if (!that.ready) {
+ done = true;
+ that.busy = false;
+ that.releaseUnit(releaseControl, true);
+ } else {
+ w = lane[x];
+ switch (state) {
+ case 1: // initial state: skip over flaw words
+ if (w == that.markerGap) {
+ state = 2;
+ } else if (w != that.markerFlaw) {
+ state = 3;
+ } else {
+ ++x;
+ }
+ break;
+ case 2: // count inter-block gap words
+ if (w != that.markerGap) {
+ state = 3;
+ } else {
+ ++x;
+ ++gapCount;
+ if (gapCount > that.startOfBlockWords) {
+ done = true;
+ advance.call(that, x, turnaround);
+ }
+ }
+ break;
+ case 3: // search for end of block (next inter-block gap word)
+ if (w != that.markerGap) {
+ ++x;
+ } else {
+ done = true;
+ advance.call(that, x, spaceForward);
+ }
+ break;
+ } // switch state
+ }
+ } while (!done);
+
+ }
+
+ if (this.busy) {
+ result = true; // unit busy
+ } else if (!this.ready) {
+ result = true; // unit not ready
+ } else if (this.atEOT) {
+ result = true; // tape at EOT, leave control hung
+ } else {
+ this.busy = true;
+ this.designatedLamp.set(1);
+ this.setAtBOT(false);
+
+ // Begin with a delay for start-up time
+ setCallback(this.mnemonic, this, this.startTime, spaceForward);
+ }
+
+ //console.log(this.mnemonic + " positionAtEnd: result=" + result.toString());
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.laneSelect = function laneSelect(laneNr, releaseControl) {
+ /* Selects the tape lane on the unit. If the drive is busy or not ready,
+ returns true */
+ delay = 3; // ms for a no-lane change
+ var lane = laneNr%2;
+ var result = false;
+
+ if (this.busy) {
+ result = true; // unit busy
+ } else if (!this.ready) {
+ result = true; // unit not ready
+ } else {
+ this.busy = true;
+ this.designatedLamp.set(1);
+ if (this.laneNr != lane) {
+ delay += 70; // additional time (ms) if the lane changes
+ this.laneNr = laneNr%2;
+ }
+
+ setCallback(this.mnemonic, this, delay, this.releaseUnit, releaseControl);
+ }
+
+ //console.log(this.mnemonic + " lane-select: lane=" + laneNr + ", result=" + result.toString());
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.rewind = function rewind(laneNr, lockout, unitFinished) {
+ /* Initiates a rewind operation on the unit. If the drive is busy or not ready,
+ returns true. Otherwise, makes the drive not-ready, delays for an
+ appropriate amount of time depending on how far up-tape we are, then readies the
+ unit again */
+ var result = false;
+
+ if (this.busy) {
+ result = true; // unit busy
+ } else if (!this.ready) {
+ result = true; // unit not ready
+ } else {
+ this.designatedLamp.set(1);
+ this.tapeRewind(laneNr, lockout, unitFinished);
+ }
+
+ //console.log(this.mnemonic + " rewind: lane=" + laneNr + ", lockout=" + lockout + ", result=" + result.toString());
+ return result;
+};
+
+/**************************************/
+B220MagTapeDrive.prototype.shutDown = function shutDown() {
+ /* Shuts down the device */
+
+ if (this.timer) {
+ clearCallback(this.timer);
+ }
+ this.window.removeEventListener("beforeunload", B220MagTapeDrive.prototype.beforeUnload, false);
+ this.window.close();
+ if (this.loadWindow && !this.loadWindow.closed) {
+ this.loadWindow.close();
+ }
+};
diff --git a/webUI/B220MagTapeLoadPanel.html b/webUI/B220MagTapeLoadPanel.html
new file mode 100644
index 0000000..7fba338
--- /dev/null
+++ b/webUI/B220MagTapeLoadPanel.html
@@ -0,0 +1,69 @@
+
+
+
+
+220 Emulator Magnetic Tape Loader
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Format
+
+
+
+
+
+
+
+ To load a blank tape, simply click OK; otherwise
+ select a tape-image file before clicking OK.
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/webUI/B220Manifest.appcache b/webUI/B220Manifest.appcache
index 60efdb1..b8f7909 100644
--- a/webUI/B220Manifest.appcache
+++ b/webUI/B220Manifest.appcache
@@ -1,5 +1,5 @@
CACHE MANIFEST
-# retro-220 emulator 0.03, 2017-05-29 13:30
+# retro-220 emulator 0.03a, 2017-10-19 08:45
CACHE:
../emulator/B220Processor.js
B220.css
@@ -30,13 +30,13 @@ B220ControlConsole.js
#B220DataFile.js
B220DiagMonitor.html
B220FramePaper.html
-#B220MagTapeControl.css
-#B220MagTapeControl.html
-#B220MagTapeControl.js
-#B220MagTapeDrive.css
-#B220MagTapeDrive.html
-#B220MagTapeDrive.js
-#B220MagTapeLoadPanel.html
+B220MagTapeControl.css
+B220MagTapeControl.html
+B220MagTapeControl.js
+B220MagTapeDrive.css
+B220MagTapeDrive.html
+B220MagTapeDrive.js
+B220MagTapeLoadPanel.html
B220PanelUtil.js
B220PaperTapePunch.css
B220PaperTapePunch.html
@@ -60,7 +60,7 @@ resources/DejaVuSans-webfont.ttf
resources/DejaVuSans-webfont.woff
resources/DejaVuSansMono-webfont.ttf
resources/DejaVuSansMono-webfont.woff
-#resources/MagTapeReel.jpg
+resources/MagTapeReel.jpg
resources/Organ-Switch-Down.png
resources/Organ-Switch-Up.png
resources/retro-220-Logo.png
diff --git a/webUI/B220PanelUtil.js b/webUI/B220PanelUtil.js
index e448014..bba0047 100644
--- a/webUI/B220PanelUtil.js
+++ b/webUI/B220PanelUtil.js
@@ -824,7 +824,6 @@ PanelRegister.prototype.drawBox = function drawBox(col, lamps, rows, leftStyle,
leftStyle and rightStyle specify the left and right borders of the box using
standard CSS border syntax. Returns the box element */
var box = document.createElement("div");
- var rightBias = (rightStyle ? 1 : 0);
box.style.position = "absolute";
box.style.left = (this.xCoord(col) - (PanelRegister.hSpacing-PanelRegister.lampDiameter)/2 + 1).toString() + "px";
diff --git a/webUI/B220PaperTapePunch.css b/webUI/B220PaperTapePunch.css
index 8ece032..b61a94a 100644
--- a/webUI/B220PaperTapePunch.css
+++ b/webUI/B220PaperTapePunch.css
@@ -44,7 +44,8 @@
position: absolute;
width: 24px;
left: 56px;
- top: 14px}
+ top: 14px;
+ box-shadow: 3px 3px 2px #999}
#ReadyLampCaption {
width: 36px;
left: 52px;
@@ -57,7 +58,8 @@
right: 8px;
top: 18px;
color: white;
- background-color: #333}
+ background-color: #333;
+ box-shadow: 3px 3px 2px #999}
#UnitDesignateKnobCaption {
width: 64px;
right: 8px;
diff --git a/webUI/B220PaperTapePunch.js b/webUI/B220PaperTapePunch.js
index 6e3d48c..59eca68 100644
--- a/webUI/B220PaperTapePunch.js
+++ b/webUI/B220PaperTapePunch.js
@@ -15,7 +15,7 @@
/**************************************/
function B220PaperTapePunch(mnemonic, unitIndex, config) {
/* Constructor for the Console Paper Tape Punch object */
- var top = unitIndex*32 + 360;
+ var top = unitIndex*32 + 264;
var left = (unitIndex-1)*32;
this.config = config; // System configuration object
diff --git a/webUI/B220PaperTapeReader.css b/webUI/B220PaperTapeReader.css
index 765b553..fe5cc28 100644
--- a/webUI/B220PaperTapeReader.css
+++ b/webUI/B220PaperTapeReader.css
@@ -44,7 +44,8 @@
position: absolute;
width: 24px;
left: 56px;
- top: 14px}
+ top: 14px;
+ box-shadow: 3px 3px 2px #999}
#ReadyLampCaption {
width: 36px;
left: 52px;
@@ -75,7 +76,8 @@
right: 8px;
top: 18px;
color: white;
- background-color: #333}
+ background-color: #333;
+ box-shadow: 3px 3px 2px #999}
#UnitDesignateKnobCaption {
width: 64px;
right: 8px;
diff --git a/webUI/B220PaperTapeReader.js b/webUI/B220PaperTapeReader.js
index ec6ba5c..9b2b3a8 100644
--- a/webUI/B220PaperTapeReader.js
+++ b/webUI/B220PaperTapeReader.js
@@ -18,7 +18,7 @@
/**************************************/
function B220PaperTapeReader(mnemonic, unitIndex, config) {
/* Constructor for the PaperTapeReader object */
- var top = unitIndex*32 + 360;
+ var top = unitIndex*32 + 264;
var left = (unitIndex-1)*32 + 250;
this.config = config; // System configuration object
diff --git a/webUI/B220SetCallback.js b/webUI/B220SetCallback.js
index 8fde89b..aa4870d 100644
--- a/webUI/B220SetCallback.js
+++ b/webUI/B220SetCallback.js
@@ -18,8 +18,8 @@
* minimum they use, and their precision in activating the call-back function
* once the actual delay is established varies even more. This module will use
* setTimeout() if the requested delay time is above a certain threshold, and
-* a setImmediate-like mechanism (based on window.postMessage) if the requested
-* delay is below that threshold.
+* a setImmediate-like mechanism (based on Promise) if the requested delay is
+* below that threshold.
*
* To help compensate for the fact that the call-back function may be called
* sooner than requested, and that due either to other activity or to browser
@@ -43,9 +43,9 @@
* earlier or later than the specified delay. The string "category" (which
* may be empty, null, or undefined) defines the category under which the
* average delay difference will be maintained. setCallBack returns a
-* numeric token identifying the call-back event, which can be used
-* with clearCallback(). Note that passing a string in lieu of a function
-* object is not permitted.
+* numeric token identifying the call-back event, which can be used with
+* clearCallback() to cancel the callback. Note that passing a string in
+* lieu of a function object is not permitted.
*
* clearCallBack(token)
*
@@ -77,6 +77,8 @@
* Original version, cloned from retro-205 emulator D205SetCallback.js.
* 2017-02-18 P.Kimpel
* Redesign yet again the delay adjustment mechanism -- from 205 project.
+* 2017-10-16 P.Kimpel
+* Replace window.postMessage yield mechanism with one based on Promise().
***********************************************************************/
"use strict";
@@ -89,7 +91,6 @@
var perf = global.performance; // cached window.performance object
var pool = []; // pool of reusable callback objects
var poolLength = 0; // length of active entries in pool
- var secretPrefix = "retro-205.webUI." + Date.now().toString(16);
/**************************************/
function activateCallback(token) {
@@ -140,7 +141,7 @@
/* Sets up and schedules a callback for function "fcn", called with context
"context", after a delay of "delay" ms. An optional "arg" value will be passed
to "fcn". If the delay is less than "minTimeout", a setImmediate-like mechanism
- based on window.postsMessage() will be used; otherwise the environment's standard
+ based on DOM Promise() will be used; otherwise the environment's standard
setTimeout mechanism will be used */
var adj = 0; // adjustment to delay and delayDev[]
var categoryName = (category || "NUL").toString();
@@ -213,25 +214,12 @@
thisCallback.cancelToken = global.setTimeout(activateCallback, delay, token);
} else {
thisCallback.cancelToken = 0;
- global.postMessage(secretPrefix + tokenName, "*");
+ Promise.resolve(token).then(activateCallback);
}
return token;
}
- /**************************************/
- function onMessage(ev) {
- /* Handler for the global.onmessage event. Activates the callback */
- var payload;
-
- if (ev.source === global) {
- payload = ev.data.toString();
- if (payload.substring(0, secretPrefix.length) === secretPrefix) {
- activateCallback(payload.substring(secretPrefix.length));
- }
- }
- }
-
/**************************************/
function getCallbackState(optionMask) {
/* Diagnostic function. Returns an object that, depending upon bits in
@@ -270,7 +258,7 @@
}
/********** Outer block of anonymous closure **********/
- if (!global.setCallback && global.postMessage && !global.importScripts) {
+ if (!global.setCallback && !global.importScripts) {
// Attach to the prototype of global, if possible, otherwise to global itself
var attachee = global;
@@ -282,7 +270,6 @@
}
*****/
- global.addEventListener("message", onMessage, false);
attachee.setCallback = setCallback;
attachee.clearCallback = clearCallback;
attachee.getCallbackState = getCallbackState;
diff --git a/webUI/B220SystemConfig.css b/webUI/B220SystemConfig.css
index 1ac94cf..31a7bb1 100644
--- a/webUI/B220SystemConfig.css
+++ b/webUI/B220SystemConfig.css
@@ -89,7 +89,6 @@
#ConsoleInputTable,
#ConsoleOutputTable,
#CardatronTable,
-#MagTapeOptionsTable,
#MagTapeTable {
border-spacing: 0;
border-collapse: collapse}
@@ -100,8 +99,6 @@
#ConsoleOutputTable TD,
#CardatronTable TH,
#CardatronTable TD,
-#MagTapeOptionsTable TH,
-#MagTapeOptionsTable TD,
#MagTapeTable TH,
#MagTapeTable TD {
padding-left: 4px;
diff --git a/webUI/B220SystemConfig.html b/webUI/B220SystemConfig.html
index 423fe7c..b5c964e 100644
--- a/webUI/B220SystemConfig.html
+++ b/webUI/B220SystemConfig.html
@@ -925,19 +925,10 @@
Magnetic Tape Unit Selection:
-
-
-
-
-
-
-
-
- Unit Type Designate Remote Rewind-Ready Not-Write
+ Unit Type Designate
A
@@ -959,12 +950,6 @@
diff --git a/webUI/B220SystemConfig.js b/webUI/B220SystemConfig.js
index 3594e81..537d6a1 100644
--- a/webUI/B220SystemConfig.js
+++ b/webUI/B220SystemConfig.js
@@ -107,11 +107,11 @@ B220SystemConfig.defaultConfig = {
hasMagTape: true,
units: [
null, // unit[0] not used
- {type: "MTA", designate: 0, remoteSwitch: false, rewindReadySwitch: true, notWriteSwitch: false},
+ {type: "MTA", designate: 1},
+ {type: "MTB", designate: 2},
+ {type: "NONE"},
{type: "NONE"},
{type: "NONE"},
- {type: "MTD", designate: 3, remoteSwitch: false, rewindReadySwitch: true, notWriteSwitch: false},
- {type: "MTE", designate: 4, remoteSwitch: false, rewindReadySwitch: true, notWriteSwitch: false},
{type: "NONE"},
{type: "NONE"},
{type: "NONE"},
@@ -371,15 +371,11 @@ B220SystemConfig.prototype.loadConfigDialog = function loadConfigDialog() {
cd.MagTape = B220SystemConfig.defaultConfig.MagTape;
}
- this.$$("SuppressBMod").checked = !cd.MagTape.suppressBSwitch;
for (x=1; x<=10; ++x) {
unit = cd.MagTape.units[x];
prefix = "MagTape" + x;
this.setListValue(prefix + "Type", unit.type);
- this.$$(prefix + "Designate").selectedIndex = unit.designate;
- this.$$(prefix + "Remote").checked = unit.remoteSwitch;
- this.$$(prefix + "RewindReady").checked = unit.rewindReadySwitch;
- this.$$(prefix + "NotWrite").checked = unit.notWriteSwitch;
+ this.$$(prefix + "Designate").selectedIndex = unit.designate-1;
} // for x
this.$$("MessageArea").textContent = "220 System Configuration loaded.";
@@ -509,17 +505,13 @@ B220SystemConfig.prototype.saveConfigDialog = function saveConfigDialog() {
// Magnetic Tape units
cd.MagTape.hasMagTape = false;
- cd.MagTape.suppressBSwitch = !this.$$("SuppressBMod").checked;
for (x=1; x<=10; ++x) {
unit = cd.MagTape.units[x];
prefix = "MagTape" + x;
e = this.$$(prefix + "Type");
unit.type = (e.selectedIndex < 0 ? "NONE" : e.options[e.selectedIndex].value);
- unit.designate = this.$$(prefix + "Designate").selectedIndex;
- unit.remoteSwitch = this.$$(prefix + "Remote").checked;
- unit.rewindReadySwitch = this.$$(prefix + "RewindReady").checked;
- unit.notWriteSwitch = this.$$(prefix + "NotWrite").checked;
+ unit.designate = this.$$(prefix + "Designate").selectedIndex+1;
if (unit.type != "NONE") {
cd.MagTape.hasMagTape = true;
}