controller/js/client/libs/.gitignore

+jquery.min.js
+vue.js
+lit-html/

controller/js/client/pad.js

+/*
+domain.js
+
+click-to-go, other virtual machine dwg 
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2020
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the open systems assembly protocol (OSAP) project.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+'use strict' 
+
+import dt from './drawing/domtools.js'
+
+export default function Pad() {
+    // machine size : pixel size
+    let psize = [500, 500]
+    let msize = [200, 200]
+    let scale = [msize[0] / psize[0], msize[1] / psize[1]]
+    // setup the pad
+    let dom = $('.plane').get(0)
+    let pad = $('<div>').addClass('pad').get(0)
+    $(pad).css('background-color', '#c9e5f2').css('width', `${psize[0]}px`).css('height', `${psize[1]}px`)
+    $(dom).append(pad)
+    let dft = { s: 1, x: -550, y: -550, ox: 0, oy: 0 }
+    dt.writeTransform(pad, dft)
+    // drawing lines, 
+    let segs = [] // ramps: have .pi and .pf 
+    let drawSegs = () => {
+        $(pad).children('.svgcont').remove() // rm all segs 
+        for(let seg of segs){
+            let del = [seg.pf[0] - seg.pi[0], seg.pf[1] - seg.pi[1]]
+            $(pad).append(dt.svgLine(seg.pi[0] / scale[0], seg.pi[1] / scale[1], del[0]/scale[1], del[1]/scale[1]))
+        }
+    }
+
+    this.onNewTarget = (pos) => {
+        console.warn('bind this')
+    }
+
+    this.addSeg = (ramp) => {
+        //console.warn('draw', ramp.pi, ramp.pf)
+        segs.push(ramp)
+        if(segs.length > 10) segs.shift()
+        drawSegs()
+    }
+    
+    // handle clicks 
+    pad.addEventListener('click', (evt) => {
+        if(evt.target != pad) return 
+        // scaled to machine spec, and invert y pixels -? logical 
+        let pos = [evt.layerX * scale[0], evt.layerY * scale[1]]
+        //console.warn(`X: ${pos[0].toFixed(2)}, Y: ${pos[1].toFixed(2)}`)
+        this.onNewTarget(pos)
+    })
+}
\ No newline at end of file

controller/js/client/saturn.js

+/*
+saturn.js
+
+js acceleration controller
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2020
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the open systems assembly protocol (OSAP) project.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+'use strict'
+
+import {
+	vDist,
+	vSum,
+	vLen,
+	vUnitBetween,
+	vScalar,
+	deg
+} from './utes/smallvectors.js'
+
+// should do input is 
+
+export default function Saturn() {
+	// move settings 
+	let minSpeed = 1.0      // units / s
+	let cruise = 400         // units / s
+	let accel = 1500           // units / s / s
+	let deviation = 0.5     // units of junction deviation: bigger for more instant accel at corners 
+	let period = 0.050      // minimum move time (WARN: this probably conflicts with minspeed, no?) 
+	console.warn(`SATURN minimum segment size is ${minSpeed * period}`)
+
+	// our state, 
+	let positions = [[0, 0]]
+	let speed = minSpeed
+	let streaming = false
+	let LOGRUNTIME = false
+	let LOGTIME = false
+
+	this.onRampOut = (ramp) => {
+		console.warn('bind this')
+	}
+
+	this.ship = () => {
+		streaming = true
+		//console.warn('vi', speed.toFixed(2), 'positions', JSON.parse(JSON.stringify(positions)))
+		// calculate new ramps, given current position and speed 
+		let ramps = runSaturn(positions, speed)
+		//console.log('ramps', JSON.parse(JSON.stringify(ramps)))
+		// now we can ship one, 
+		if (ramps.length < 1) return
+		this.onRampOut(JSON.parse(JSON.stringify(ramps[0])))
+		// 'current' speed as far as our scope is concerned is the speed at the end of the output ramp 
+		speed = ramps[0].vf
+		// and position is .pf, but we need to see if we've walked past a point in the stream 
+		let dtp = vDist(ramps[0].pf, positions[1])
+		//console.log(dtp, positions[1])
+		if (dtp < 0.001) {
+			// cleared last position, shift it out and update speed, 
+			//console.log('CLEAR', positions.length)
+			positions.shift()
+		} else {
+			// are mid-segment, only shift ramp, update position 
+			//console.log('MID', positions.length)
+			positions[0] = ramps[0].pf
+		}
+		// don't need to shift ramps because we'll recalc next time, 
+		// if that wasn't the last ramp, set a timer to ship next 
+		let delay = Math.max(0, ramps[0].t * 1000 - 100) // 100ms before this should finish, or *now* 
+		//console.log(`delay is ${delay}`)
+		if (ramps.length > 1) {
+			setTimeout(this.ship, delay)
+		} else {
+			streaming = false
+			//      setTimeout(() => { streaming = false }, delay)
+		}
+	}
+
+	this.checkStream = () => {
+		if (!streaming && positions.length > 1) {
+			this.ship()
+		}
+	}
+
+	// entry pt: we always accept points ? no flowcontrol yet 
+	this.newTarget = (pos) => {
+		// array of nums in unit space, 
+		//    console.log('gotem', pos)
+		try {
+			if (vDist(pos, positions[positions.length - 1]) < (minSpeed * period)) {
+				console.warn('not accepting this xtremely small segment')
+			} else {
+				positions.push(pos)
+				this.checkStream()
+			}
+		} catch (err) {
+			console.warn('err at saturn input', err)
+		}
+	}
+
+	this.reset = () => {
+		positions = [[0, 0]]
+		speed = minSpeed
+	}
+
+	// ---------------------------------------------------- Period Pass 
+	let periodPass = (posns, speeds, debug) => {
+		for (let i = posns.length - 2; i > 0; i--) {
+			// distance to make,
+			let d = vDist(posns[i], posns[i + 1])
+			// the *fastest* we could go if we go flat out, in one period, is
+			let v = d / period
+			// set self,
+			speeds[i] = v
+			// traceback:
+			if (speeds[i + 1] > speeds[i]) {
+				speeds[i + 1] = v
+			}
+		}
+	}
+
+	// ---------------------------------------------------- Junction Deviation 
+	let jd = (posns, speeds, debug) => {
+		//console.log('posns', posns)
+		let calcJunctionSpeed = (p0, p1, p2, debug) => {
+			// junction speed at p1, arrival from p0 exit to p2
+			let v0 = math.subtract(p1, p0)
+			let v1 = math.subtract(p2, p1)
+			if (debug) console.log('for\n', v0, v1)
+			let dotprod = math.dot(v0, v1) / (vLen(v0) * vLen(v1))
+			if (debug) console.log('dotprod', dotprod)
+			// block for floating pt errors that drive this term past +/- 1
+			if (dotprod < 1) dotprod = -1
+			if (dotprod > 1) dotprod = 1
+			let omega = Math.PI - Math.acos(dotprod)
+			if (debug) console.log('angle between', deg(omega))
+			let r = deviation / (1 / Math.cos(Math.PI / 2 - omega / 2) - 1)
+			if (debug) console.log('rad', r)
+			let v = Math.sqrt(accel * r)
+			if (debug) console.log('permissible', v)
+			return v
+		}
+		// the ops,
+		for (let m = 0; m < posns.length; m++) {
+			if (m === 0) continue // noop for start: this is our current speed, should already be in speeds arr
+			if (m === posns.length - 1) continue // noop for last move, nothing to junction into, exit should be minspeed
+			let jd = calcJunctionSpeed(posns[m - 1], posns[m], posns[m + 1])
+			if (Number.isNaN(jd)) {
+				console.warn(`after jd, NaN for move at ${m}`, posns[m - 1], posns[m], posns[m + 1])
+				// run again w/ debug
+				calcJunctionSpeed(posns[m - 1], posns[m], posns[m + 1], true)
+			}
+			if (jd < speeds[m]) {
+				speeds[m] = jd
+			}
+		}
+		// walk for minspeeds
+		for (let s in speeds) {
+			if (speeds[s] < minSpeed) speeds[s] = minSpeed
+			if (speeds[s] > cruise) speeds[s] = cruise
+		}
+		// that's it for us
+		return speeds
+	}
+
+	// ---------------------------------------------------- Reverse Pass 
+	let reversePass = (posns, speeds, debug) => {
+		// link, walking back from last
+		// this makes sure we can completely decelerate, through moves, to the last point at zero
+		for (let i = posns.length - 2; i > 0; i--) {
+			if (debug) console.log(`reverse pass for ${i}\n`, posns[i], posns[i + 1])
+			if (debug) console.log(`current entrance to calculate is`, speeds[i])
+			if (debug) console.log(`the constraining exit is`, speeds[i + 1])
+			// to calcluate the maximum entrance, given our exit, with pure acceleration:
+			let d = vLen(math.subtract(posns[i + 1], posns[i]))
+			let maxEntranceByAccel = Math.sqrt(Math.pow(speeds[i + 1], 2) + 2 * accel * d)
+			let max = Math.max(minSpeed, Math.min(speeds[i], maxEntranceByAccel))
+			// just for logging
+			let temp = speeds[i]
+			// stay safe w/ current state at zero
+			if (i === 0) {
+				// only the future can be modified
+			} else {
+				speeds[i] = max
+			}
+			if (debug) console.log(`entrance was ${temp}, now ${speeds[i]}`)
+		}
+	}
+
+	// ---------------------------------------------------- Forward Pass
+	let forwardPass = (posns, speeds, debug) => {
+		// link, walk forwards: can we accel to these velocities in time?
+		for (let i = 0; i < posns.length - 2; i++) {
+			if (debug) console.log(`forwards pass for ${i}\n`, posns[i], posns[i + 1])
+			if (debug) console.log(`current exit to calculate is`, speeds[i + 1])
+			if (debug) console.log(`the constraining entrance is`, speeds[i])
+			let d = vLen(math.subtract(posns[i + 1], posns[i]))
+			let maxExitByAccel = Math.sqrt(Math.pow(speeds[i], 2) + 2 * accel * d)
+			let max = Math.max(minSpeed, Math.min(speeds[i + 1], maxExitByAccel))
+			let temp = speeds[i + 1]
+			if (i === posns.length - 2) {
+				// tail should always be minspeed, if not, trouble
+				if (max > minSpeed) console.warn('trouble halting early')
+			} else {
+				speeds[i + 1] = max
+			}
+			if (debug) console.log(`exit was ${temp}, now ${speeds[i + 1]}`)
+		}
+		// link forwards, now making sure we can accel from our start speed up to the exit
+		// here is assuming posns[0] is current position, for which speed is the current velocity
+	}
+
+	// ---------------------------------------------------- Check Segs are all < minTime 
+	let posnsCheck = (posns, speeds) => {
+		for (let i = 0; i < posns.length - 1; i++) {
+			let d = vDist(posns[i], posns[i + 1])
+			let vi = speeds[i]
+			let vf = speeds[i + 1]
+			let t = 2 * d / (vi + vf)
+			if (false) console.log(`ap, ${t.toFixed(3)}`)
+			if (t < (period - 0.001)) console.warn('small link in posns check')
+		}
+	}
+
+	// ---------------------------------------------------- Seg -> Ramps 
+	let writeSeg = (ramps, vi, vf, pi, pf) => {
+		let d = vDist(pi, pf)
+		ramps.push({
+			vi: vi,
+			vf: vf,
+			t: 2 * d / (vi + vf),
+			pi: pi,
+			pf: pf
+		})
+		// to trace errors, turn these on, to see which seg-writing moves might be missing steps 
+		//console.error('pi, pf')
+		//console.log(pi, pf)
+		// check gap 
+		if (ramps.length > 2) {
+			let sep = vDist(ramps[ramps.length - 2].pf, ramps[ramps.length - 1].pi)
+			if (sep > 0.001) throw new Error('HERE')
+		}
+	}
+
+	// ---------------------------------------------------- Triangle -> Seg 
+	let writeTriangle = (ramps, vi, vf, pi, pf) => {
+		let d = vDist(pi, pf)
+		// not sure when I wrote this eqn, seems to work tho
+		let vPeak = Math.sqrt(((2 * accel * d + Math.pow(vi, 2) + Math.pow(vf, 2)) / 2))
+		let acDist = (Math.pow(vPeak, 2) - Math.pow(vi, 2)) / (2 * accel)
+		let pInter = math.add(pi, vScalar(vUnitBetween(pi, pf), acDist))
+		// finally, we have to check here if either / or side is too small, then default to smallticks
+		let tSeg1 = (vPeak - vi) / accel
+		let tSeg2 = (vPeak - vf) / accel
+		if (tSeg1 < period || tSeg2 < period) {
+			// bail hard, write one seg only
+			writeSeg(ramps, vi, vf, pi, pf)
+		} else {
+			// write two segs,
+			writeSeg(ramps, vi, vPeak, pi, pInter)
+			writeSeg(ramps, vPeak, vf, pInter, pf)
+		}
+	}
+
+	// ---------------------------------------------------- Ramp Pass 
+	// turn posns, speeds into segments, writing accelerations between
+	let rampPass = (posns, speeds, debug) => {
+		let rmps = []
+		for (let i = 0; i < posns.length - 1; i++) {
+			let numRampsBefore = rmps.length
+			if (debug) console.log(`ramp pass for ${i}`)
+			let pi = posns[i]
+			let pf = posns[i + 1]
+			let vi = speeds[i]
+			let vf = speeds[i + 1]
+			let d = vDist(pi, pf)
+			let maxEntry = Math.sqrt(Math.pow(speeds[i + 1], 2) + 2 * accel * d)
+			let maxExit = Math.sqrt(Math.pow(speeds[i], 2) + 2 * accel * d)
+			if (debug) console.log(`entrance speed is ${vi}`)
+			if (debug) console.log(`exit speed is ${vf}`)
+			if (debug) console.log(`d is ${d}, maxEntry ${maxEntry}, maxExit ${maxExit}`)
+			// big switch
+			if (maxExit <= vf) {
+				// the all-up and all-down segments should always be clear:
+				// since we already swept for these cases in the revpass
+				if (debug) console.log(`/`)
+				writeSeg(rmps, vi, vf, pi, pf)
+			} else if (maxEntry <= vi) {
+				if (debug) console.log('\\')
+				writeSeg(rmps, vi, vf, pi, pf)
+			} else if (vi === cruise && vf === cruise) {
+				// similarely, since we're not segmenting cruise any farther, it should also be OK
+				if (debug) console.log('--')
+				writeSeg(rmps, vi, vf, pi, p)
+			} else if (vi === cruise) {
+				if (debug) console.log('--\\')
+				let dcDist = (Math.pow(vi, 2) - Math.pow(vf, 2)) / (2 * accel) // distance to deccelerate
+				let pInter = math.add(pf, vScalar(vUnitBetween(pf, pi), dcDist))
+				// now, we need to tune accel / cruise phases so that neither t is < 1 period
+				let tSeg1 = (d - dcDist) / vi
+				let tSeg2 = (vi - vf) / accel
+				if (tSeg1 < period || tSeg2 < period) {
+					// small segs, just write as one downtick,
+					writeSeg(rmps, vi, vf, pi, pf)
+				} else {
+					// if these are both > one period, we can write 'em
+					writeSeg(rmps, vi, vi, pi, pInter)
+					writeSeg(rmps, vi, vf, pInter, pf)
+				}
+			} else if (vf === cruise) {
+				if (debug) console.log('/--')
+				let acDist = (Math.pow(cruise, 2) - Math.pow(vi, 2)) / (2 * accel)
+				let pInter = math.add(pi, vScalar(vUnitBetween(pi, pf), acDist))
+				// I feel the same about this as I did above
+				let tSeg1 = (cruise - vi) / accel
+				let tSeg2 = (d - acDist) / cruise
+				if (tSeg1 < period || tSeg2 < period) {
+					writeSeg(rmps, vi, vf, pi, pf)
+				} else {
+					writeSeg(rmps, vi, vf, pi, pInter)
+					writeSeg(rmps, vf, vf, pInter, pf)
+				}
+			} else {
+				// here we will handle triangles '/\' and 'full trapezoids' '/--\'
+				let dcDist = (Math.pow(cruise, 2) - Math.pow(vf, 2)) / (2 * accel)
+				let acDist = (Math.pow(cruise, 2) - Math.pow(vi, 2)) / (2 * accel)
+				if (dcDist + dcDist >= d) {
+					if (debug) console.log('/\\')
+					writeTriangle(rmps, vi, vf, pi, pf)
+				} else { // BEGIN TRAP SELECTIONS
+					if (debug) console.log('/--\\')
+					let pa = math.add(pi, vScalar(vUnitBetween(pi, pf), acDist))
+					let pb = math.add(pf, vScalar(vUnitBetween(pf, pi), dcDist))
+					// ok,
+					let tSeg1 = (cruise - vi) / accel
+					let tSeg2 = (d - acDist - dcDist) / cruise
+					let tSeg3 = (cruise - vf) / accel
+					// here we go
+					if (tSeg2 < period) {
+						// for this case, contencating into a triangle is fine... it will be within ~ 50ms of extra accel time: not much
+						if (debug) console.log('/\\')
+						writeTriangle(rmps, vi, vf, pi, pf)
+					} else if (tSeg1 < period && tSeg3 < period) {
+						// contencate into one ramp
+						writeSeg(rmps, vi, vf, pi, pf)
+					} else if (tSeg1 < period) {
+						// first segment smaller: second larger, third larger
+						// contencate first, second into one, then write last
+						writeSeg(rmps, vi, cruise, pi, pb)
+						writeSeg(rmps, cruise, vf, pb, pf)
+					} else if (tSeg3 < period) {
+						// last segment smaller: second larger, first larger
+						// write first, then contencate second, third into one
+						writeSeg(rmps, vi, cruise, pi, pa)
+						writeSeg(rmps, cruise, vf, pa, pf)
+					} else {
+						// forgot the genuine full cruiser, here it is
+						writeSeg(rmps, vi, cruise, pi, pa)
+						writeSeg(rmps, cruise, cruise, pa, pb)
+						writeSeg(rmps, cruise, vf, pb, pf)
+					}
+				} // end TRAP SELECTIONS
+			} // end BIGSWITCH
+			if (rmps.length === numRampsBefore) console.warn('zero ramps written for', pi, pf, vi, vf)
+		} // end for-over-posns
+		return rmps
+	}
+
+	// ---------------------------------------------------- Check Ramps are all in spec
+	let rampCheck = (ramps) => {
+		for (let i = 0; i < ramps.length; i++) {
+			let r = ramps[i]
+			let d = vDist(r.pi, r.pf)
+			let t = 2 * d / (r.vi + r.vf)
+			if (t < (period - 0.001)) console.warn('troublesome ramp, small time', r)
+			// more than 10% over speed is probably not cool,
+			let cruiseAbsMax = cruise + 0.15 * cruise
+			if (r.vi > cruiseAbsMax || r.vf > cruiseAbsMax) console.warn('troublesome ramp, high speed', r)
+			// check that ramps are continuous
+			if (i < ramps.length - 2) {
+				let sep = vDist(r.pf, ramps[i + 1].pi)
+				if (sep > 0.001) console.warn('disconnected ramp junction', r, ramps[i + 1])
+			}
+		}
+	}
+
+	// should return ramps for given posns, where p[0] is current pos, and speed is vi 
+	let runSaturn = (posns, speed) => {
+		if (LOGRUNTIME) console.log('runSaturn')
+		if (LOGTIME) console.time('lookahead')
+		// posns[] is global, generate speeds for 
+		let speeds = new Array(posns.length)
+		speeds[0] = speed // begin at current speed, 
+		speeds[speeds.length - 1] = minSpeed // end at target min velocity (stopped)
+		// first, set all speeds such that moves can be made within single periods 
+		periodPass(posns, speeds)
+		// juction deviation calculates maximum allowable instantaneous acceleration through corners 
+		jd(posns, speeds)
+		// reverse pass, links through moves such that we can decelerate successfully to the end 
+		reversePass(posns, speeds)
+		// forward pass accelerates through, 
+		forwardPass(posns, speeds)
+		// check speeds are all sound after these passes (for mintime / period) 
+		posnsCheck(posns, speeds)
+		// re-generate the ramps, 
+		let ramps = rampPass(posns, speeds, false)
+		// check ramps are all sequential 
+		rampCheck(ramps)
+		if (LOGTIME) console.timeLog('lookahead')
+		if (LOGTIME) console.timeEnd('lookahead')
+		return ramps
+	}
+}
\ No newline at end of file

controller/js/client/style.css

+html {
+	height: 100%;
+	/*
+	margin: 0px;
+	padding: 0px;
+	*/
+}
+
+body {
+	height: 100%;
+	overflow: hidden;
+	margin: 0px;
+	padding: 0px;
+	font-family: Palatino, serif;
+	font-size: 11px;
+}
+
+#wrapper {
+	overflow: hidden;
+	width: 100%;
+	height: 100%;
+	padding: 0px;
+	margin: 0px;
+	background: #fff;
+	/*background-image:url("background.png");*/
+	/*background-origin: content-box;*/
+	background-image:
+		linear-gradient(rgba(225, 225, 225, .2) 1px, transparent 1px),
+		linear-gradient(90deg, rgba(225, 225, 225, .2) 1px, transparent 1px);
+	background-size: 10px 10px;
+}
+
+.plane {
+	position: absolute;
+	width: 10px;
+	height: 10px;
+}
+
+.pad {
+	position: absolute;
+}
+
+.flag {
+	position: absolute;
+	width: 20px;
+	height: 20px;
+}
+
+.button {
+	position: absolute;
+	width: 100px;
+	height: 20px;
+	padding: 5px;
+	background-color: #dbdbdb;
+	color: #000;
+	font-size: 15px;
+	text-align: center;
+}
+
+.button:hover{
+	background-color: #e6e6e6;
+	cursor: pointer;
+}
+
+.inputwrap{
+	position:absolute;
+	width: 100px;
+	height: 20px;
+	padding: 5px;
+	border: none;
+	background-color: #dbdbdb;
+}
+
+.chart{
+	position: absolute;
+	background-color: #dbdbdb;
+}
+
+/* svg bs */
+
+.svgcont {
+	position: absolute;
+	overflow: visible;
+	width: 5px;
+	height: 5px;
+}
+
+/* nodes */
+
+.node {
+	position:absolute;
+	background-color: #f5f5f5;
+}
+
+.nodename {
+	font-size: 11px;
+	font-family: Helvetica, sans-serif;
+	width: 100px;
+	padding-left: 5px;
+	padding-top: 5px;
+	transform-origin: 0 0;
+	transform: rotate(-90deg);
+}
+
+/* vPorts */
+
+.vPort {
+	position: absolute;
+	background-color: #ebebeb;
+	border-left: 2px solid black;
+	border-right: 2px solid black;
+}
+
+.vPortname {
+	font-size: 11px;
+	font-family: Helvetica, sans-serif;
+	width: 120px;
+	padding-left: 5px;
+	padding-top: 3px;
+	transform-origin: 0 0;
+	transform: rotate(-90deg) translate(-110px, 0px);
+}
+
+/* s/o https://brm.io/dat-gui-light-theme/ */
+
+.dg.main.taller-than-window .close-button {
+    border-top: 1px solid #ddd;
+}
+
+.dg.main .close-button {
+    background-color: #ccc;
+}
+
+.dg.main .close-button:hover {
+    background-color: #ddd;
+}
+
+.dg {
+    color: #555;
+    text-shadow: none !important;
+}
+
+.dg.main::-webkit-scrollbar {
+    background: #fafafa;
+}
+
+.dg.main::-webkit-scrollbar-thumb {
+    background: #bbb;
+}
+
+.dg li:not(.folder) {
+    background: #fafafa;
+    border-bottom: 1px solid #ddd;
+}
+
+.dg li.save-row .button {
+    text-shadow: none !important;
+}
+
+.dg li.title {
+    background: #e8e8e8 url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlI+hKgFxoCgAOw==) 6px 10px no-repeat;
+}
+
+.dg .cr.function:hover,.dg .cr.boolean:hover {
+    background: #fff;
+}
+
+.dg .c input[type=text] {
+    background: #e9e9e9;
+}
+
+.dg .c input[type=text]:hover {
+    background: #eee;
+}
+
+.dg .c input[type=text]:focus {
+    background: #eee;
+    color: #555;
+}
+
+.dg .c .slider {
+    background: #e9e9e9;
+}
+
+.dg .c .slider:hover {
+    background: #eee;
+}

controller/js/client/utes/lineChart.js

+/*
+lineChart.js
+
+draws data to line chart
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2019
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the squidworks and cuttlefish projects.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+// using https://bl.ocks.org/d3noob/402dd382a51a4f6eea487f9a35566de0
+
+export default function LineChart() {
+  // dom elements 
+  this.de = $('<div>').addClass('chart')
+  let uid = `lineChart_${parseInt(Math.random()*1000)}_uid`
+  $(this.de).attr('id', uid)
+  let cwidth = 500 
+  let cheight = 500 
+  $(this.de).css('width', `${cwidth}px`).css('height', `${cheight}px`)
+  // our vars,
+  var margin = {
+      top: 20,
+      right: 20,
+      bottom: 30,
+      left: 90
+    }
+  let width = cwidth - margin.left - margin.right
+  let height = cheight - margin.top - margin.bottom
+  var x = d3.scaleLinear().range([0, width])
+  var y = d3.scaleLinear().range([height, 0])
+  var thesvg = null
+  // make ah function
+  this.draw = (data) => {
+    var valueline = d3.line()
+      .x(function(d) {
+        return x(d[0])
+      })
+      .y(function(d) {
+        return y(d[1])
+      })
+    // scale
+    x.domain([d3.min(data, function(d) {
+      return d[0]
+    }), d3.max(data, function(d) {
+      return d[0];
+    })])
+    y.domain([d3.min(data, function(d) {
+      return d[1]
+    }), d3.max(data, function(d) {
+      return d[1];
+    })])
+    if (thesvg) {
+      d3.select(`#${uid}`).selectAll("*").remove()
+    }
+    thesvg = d3.select(`#${uid}`).append("svg")
+      .attr("width", width + margin.left + margin.right)
+      .attr("height", height + margin.top + margin.bottom)
+      .append("g")
+      .attr("transform", "translate(" + margin.left + "," + margin.top + ")");
+    // write it?
+    thesvg.append("path")
+      .data([data])
+      .attr("class", "line")
+      .attr("stroke-width", "2px")
+      .attr("stroke", "black")
+      .attr("fill", "none")
+      .attr("d", valueline)
+    // write the x axis
+    thesvg.append("g")
+      .attr("transform", "translate(0," + height + ")")
+      .call(d3.axisBottom(x))
+    // the y axis
+    thesvg.append("g")
+      .call(d3.axisLeft(y))
+  }
+}

controller/js/client/utes/lsq.js

+/*
+
+lsq.js 
+
+input previous system measurements as state (lists)
+make predictions for y based on input at x, with lsq. from old data
+
+*/
+
+import smallmath from './smallmath.js'
+
+export default function LeastSquares() {
+  // internal state 
+  let observations = []
+  let m = 1 
+  let b = 0
+
+  // setup 
+  this.setObservations = (xy) => {
+    observations = JSON.parse(JSON.stringify(xy))
+    if(observations[0].length > 2){
+      let lsqr = smallmath.lsq(observations[0], observations[1])
+      m = lsqr.m 
+      b = lsqr.b 
+    }
+  }
+
+  // to generate human-readable interp of model 
+  this.printFunction = () => {
+    if (b >= 0) {
+      return `${m.toExponential(2)} x + ${b.toExponential(2)}`
+    } else {
+      return `${m.toExponential(2)} x ${b.toExponential(2)}`
+    }
+  }
+
+  this.predict = (x) => {
+    return m * x + b 
+  }
+}

controller/js/client/utes/smallmath.js

+// least squares from https://medium.com/@sahirnambiar/linear-least-squares-a-javascript-implementation-and-a-definitional-question-e3fba55a6d4b
+// mod to return object of m, b, values.x, values.y,
+var smallmath = {
+  lsq: function(values_x, values_y) {
+    var x_sum = 0;
+    var y_sum = 0;
+    var xy_sum = 0;
+    var xx_sum = 0;
+    var count = 0;
+
+    /*
+     * The above is just for quick access, makes the program faster
+     */
+    var x = 0;
+    var y = 0;
+    var values_length = values_x.length;
+
+    if (values_length != values_y.length) {
+      throw new Error('The parameters values_x and values_y need to have same size!');
+    }
+
+    /*
+     * Above and below cover edge cases
+     */
+    if (values_length === 0) {
+      return [
+        [],
+        []
+      ];
+    }
+
+    /*
+     * Calculate the sum for each of the parts necessary.
+     */
+    for (let i = 0; i < values_length; i++) {
+      x = values_x[i];
+      y = values_y[i];
+      x_sum += x;
+      y_sum += y;
+      xx_sum += x * x;
+      xy_sum += x * y;
+      count++;
+    }
+
+    /*
+     * Calculate m and b for the line equation:
+     * y = x * m + b
+     */
+    var m = (count * xy_sum - x_sum * y_sum) / (count * xx_sum - x_sum * x_sum);
+    var b = (y_sum / count) - (m * x_sum) / count;
+
+    /*
+     * We then return the x and y data points according to our fit
+     */
+    var result_values_x = [];
+    var result_values_y = [];
+
+    for (let i = 0; i < values_length; i++) {
+      x = values_x[i];
+      y = x * m + b;
+      result_values_x.push(x);
+      result_values_y.push(y);
+    }
+
+    return {
+      m: m,
+      b: b,
+      values: {
+        x: result_values_x,
+        y: result_values_y
+      }
+    }
+  }
+}
+
+export default smallmath

controller/js/client/utes/smallvectors.js

+let vDist = (v1, v2) => {
+    // takes v1, v2 to be arrays of same length
+    // computes cartesian distance
+    var sum = 0
+    for (let i = 0; i < v1.length; i++) {
+        sum += (v1[i] - v2[i]) * (v1[i] - v2[i])
+    }
+    return Math.sqrt(sum)
+}
+
+let vSum = (v1, v2) => {
+  let ret = []
+  for(let i = 0; i < v1.length; i ++){
+    ret.push(v1[i] + v2[i])
+  }
+  return ret
+}
+
+let vLen = (v) => {
+  let sum = 0
+  for(let i = 0; i < v.length; i ++){
+    sum += Math.pow(v[i], 2)
+  }
+  return Math.sqrt(sum)
+}
+
+// from v1 to v2,
+let vUnitBetween = (v1, v2) => {
+  let dist = vDist(v1, v2)
+  let ret = []
+  for(let i = 0; i < v1.length; i ++){
+    ret[i] = (v2[i] - v1[i]) / dist
+  }
+  return ret
+}
+
+let vScalar = (v, s) => {
+  let ret = []
+  for(let i = 0; i < v.length; i ++){
+    ret[i] = v[i] * s
+  }
+  return ret
+}
+
+let deg = (rad) => {
+  return rad * (180 / Math.PI)
+}
+
+export { vDist, vSum, vLen, vUnitBetween, vScalar, deg }

controller/js/core/ts.js

+/*
+ts.js // typeset
+
+serialization, keys for DEX
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2020
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the open systems assembly protocol (OSAP) project.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+let TS = {}
+
+let decoder = new TextDecoder()
+
+let tempDataView = {}
+
+TS.read = (type, buffer, start, keyless) => {
+  if (!keyless) {
+    throw new Error('need code here for key checking')
+  }
+  switch (type) {
+    case 'uint8':
+      return buffer[start]
+    case 'uint16':
+      // little endian: lsb is at the lowest address
+      return (buffer[start] & 255) | (buffer[start + 1] << 8)
+    case 'uint32':
+      return (buffer[start] & 255) | (buffer[start + 1] << 8) | (buffer[start + 2] << 16) | (buffer[start + 3] << 24)
+    case 'int32':
+      tempDataView = new DataView(buffer.buffer) // the actual buffer underlying the uint8array... 
+      return tempDataView.getInt32(start, true)
+    case 'boolean':
+      if (buffer[start] > 0) {
+        return true
+      } else {
+        return false
+      }
+      break;
+    case 'string':
+      let length = (buffer[start] & 255) | (buffer[start + 1] << 8) | (buffer[start + 2] << 16) | (buffer[start + 3] << 24)
+      let pckSlice = buffer.slice(start + 4, start + 4 + length)
+      return {
+        value: decoder.decode(pckSlice),
+          inc: length + 4
+      }
+      default:
+        console.error('no code for this type read')
+        return null
+        break;
+  }
+}
+
+let encoder = new TextEncoder()
+let tempArr = {}
+let tempBytes = {}
+
+TS.write = (type, value, buffer, start, keyless) => {
+  if (!keyless) {
+    throw new Error('need code here for key checking')
+  }
+  switch (type) {
+    case 'uint8':
+      buffer[start] = value & 255
+      return 1
+    case 'uint16':
+      // little endian: lsb is at the lowest address
+      buffer[start] = value & 255
+      buffer[start + 1] = (value >> 8) & 255
+      return 2
+    case 'uint32':
+      buffer[start] = value & 255
+      buffer[start + 1] = (value >> 8) & 255
+      buffer[start + 2] = (value >> 16) & 255
+      buffer[start + 3] = (value >> 24) & 255
+      return 4
+    case 'int32':
+      tempArr = Int32Array.from([value])
+      tempBytes = new Uint8Array(tempArr.buffer)
+      buffer.set(tempBytes, start)
+      return 4
+    case 'float32':
+      tempArr = Float32Array.from([value])
+      tempBytes = new Uint8Array(tempArr.buffer)
+      buffer.set(tempBytes, start)
+      return 4 
+    case 'char':
+      //      console.log('char', value.charCodeAt(0))
+      buffer[start] = value.charCodeAt(0)
+      return 1
+    case 'string': // so, would be good to send long strings (i.e. dirty old gcodes), so 32b base
+      let stringStream = encoder.encode(value)
+      //console.log("WRITING STRING", value)
+      buffer[start] = stringStream.length & 255
+      buffer[start + 1] = (stringStream.length >> 8) & 255
+      buffer[start + 2] = (stringStream.length >> 16) & 255
+      buffer[start + 3] = (stringStream.length >> 24) & 255
+      buffer.set(stringStream, start + 4)
+      return 4 + stringStream.length
+    case 'boolean':
+      if (value) {
+        buffer[start] = 1
+      } else {
+        buffer[start] = 0
+      }
+      return 1
+    default:
+      console.error('no code for this type write')
+      return null
+      break;
+  }
+}
+
+TS.logPacket = (buffer) => {
+  // log a pretty buffer
+  // buffers should all be Uint8Array views,
+  let pert = []
+  for (let i = 0; i < buffer.length; i++) {
+    pert.push(buffer[i])
+  }
+  console.log(pert)
+}
+
+export {
+  TS
+}

controller/js/dexs.js

+/*
+dex-server
+
+serves dex tools 
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2020
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the open systems assembly protocol (OSAP) project.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+// new year new bootstrap
+
+const express = require('express')
+const app = express()
+// this include lets us read data out of put requests,
+const bodyparser = require('body-parser')
+// our fs tools,
+const fs = require('fs')
+//const filesys = require('./filesys.js')
+// and we occasionally spawn local pipes (workers)
+const child_process = require('child_process')
+// will use these to figure where tf we are
+let ownIp = ''
+const os = require('os')
+
+// serve everything: https://expressjs.com/en/resources/middleware/serve-static.html
+app.use(express.static(__dirname))
+// accept post bodies as json,
+app.use(bodyparser.json())
+app.use(bodyparser.urlencoded({extended: true}))
+
+// redirect traffic to /client,
+app.get('/', (req, res) => {
+  res.redirect('/client')
+})
+
+// we also want to institute some pipes: this is a holdover for a better system
+// more akin to nautilus, where server-side graphs are manipulated
+// for now, we just want to dive down to a usb port, probably, so this shallow link is OK
+let processes = []
+app.get('/startLocal/:file', (req, res) => {
+  // launches another node instance at this file w/ these args,
+  let args = ''
+  if(req.query.args){
+    args = req.query.args.split(',')
+  }
+  console.log(`attempt to start ${req.params.file} with args ${args}`)
+  // startup, let's spawn,
+  const process = child_process.spawn('node', ['-r', 'esm', `local/${req.params.file}`])
+  // add our own tag,
+  process.fileName = req.params.file
+  let replied = false
+  let pack = ''
+  process.stdout.on('data', (buf) => {
+    // these emerge as buffers,
+    let msg = buf.toString()
+    // can only reply once to xhr req
+    if(msg.includes('OSAP-wss-addr:') && !replied){
+      res.send(msg)
+      replied = true
+    }
+    // ok, dealing w/ newlines
+    pack = pack.concat(msg)
+    let index = pack.indexOf('\n')
+    while(index >= 0){
+      console.log(`${process.fileName} ${process.pid}: ${pack.substring(0, index)}`)
+      pack = pack.slice(index + 1)
+      index = pack.indexOf('\n')
+    }
+  })
+  process.stderr.on('data', (err) => {
+    if(!replied){
+      res.send('err in local script')
+      replied = true
+    }
+    console.log(`${process.fileName} ${process.pid} err:`, err.toString())
+  })
+  process.on('close', (code) => {
+    console.log(`${process.fileName} ${process.pid} closes:`, code)
+    if(!replied){
+      res.send('local process closed')
+      replied = true
+    }
+  })
+  console.log(`started ${process.fileName} w/ pid ${process.pid}`)
+})
+
+// finally, we tell the express server to listen here:
+let port = 8080
+app.listen(port)
+
+// once we're listening, report our IP:
+let ifaces = os.networkInterfaces()
+// this just logs the processes IP's to the termina
+Object.keys(ifaces).forEach(function(ifname) {
+  var alias = 0;
+
+  ifaces[ifname].forEach(function(iface) {
+    if ('IPv4' !== iface.family){//} || iface.internal !== false) {
+      // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
+      return;
+    }
+    ownIp = iface.address
+    if (alias >= 1) {
+      console.log('dex-tool available on: \t' /*ifname + ':' + alias,*/ + iface.address + `:${port}`);
+      // this single interface has multiple ipv4 addresses
+      // console.log('serving at: ' ifname + ':' + alias + iface.address + `:${port}`);
+    } else {
+      console.log('dex-tool available on:\t' /*ifname + ':' + alias,*/ + iface.address + `:${port}`);
+      // this interface has only one ipv4 adress
+      //console.log(ifname, iface.address);
+    }
+    ++alias;
+  });
+});

controller/js/local/common/cobs.js

+/*
+cobs.js
+
+consistent overhead byte stuffing, wikipedia implementation
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2020
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the open systems assembly protocol (OSAP) project.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+function cobsEncode(buf) {
+  var dest = [0];
+  // vfpt starts @ 1,
+  var code_ptr = 0;
+  var code = 0x01;
+
+  function finish(incllast) {
+    dest[code_ptr] = code;
+    code_ptr = dest.length;
+    incllast !== false && dest.push(0x00);
+    code = 0x01;
+  }
+
+  for (var i = 0; i < buf.length; i++) {
+    if (buf[i] == 0) {
+      finish();
+    } else {
+      dest.push(buf[i]);
+      code += 1;
+      if (code == 0xFF) {
+        finish();
+      }
+    }
+  }
+  finish(false);
+
+  // close w/ zero
+  dest.push(0x00)
+
+  return Uint8Array.from(dest);
+}
+
+// COBS decode, tailing zero, that was used to delineate this buffer,
+// is assumed to already be chopped, thus the end is the end 
+
+function cobsDecode(buf) {
+  var dest = [];
+  for (var i = 0; i < buf.length;) {
+    var code = buf[i++];
+    for (var j = 1; j < code; j++) {
+      dest.push(buf[i++]);
+    }
+    if (code < 0xFF && i < buf.length) {
+      dest.push(0);
+    }
+  }
+  return Uint8Array.from(dest)
+}
+
+export default {
+  encode: cobsEncode,
+  decode: cobsDecode
+}

controller/js/local/common/wssPipe.js

+/*
+wssPipe.js
+
+automated remote-wss-server,
+
+Jake Read at the Center for Bits and Atoms
+(c) Massachusetts Institute of Technology 2020
+
+This work may be reproduced, modified, distributed, performed, and
+displayed for any purpose, but must acknowledge the open systems assembly protocol (OSAP) project.
+Copyright is retained and must be preserved. The work is provided as is;
+no warranty is provided, and users accept all liability.
+*/
+
+// so, ideally this is something that *could* get bootstrapped, if we hook it to
+// osap/local file, but could otherwise run standalone...
+// to start, will write here, then wrap in some interface...
+
+// need to know our own ip,
+import os from 'os'
+import WS from 'ws'
+const WebSocketServer = WS.Server
+//const os = require('os')
+//const WebSocketServer = require('ws').Server
+
+// find our addr,
+let wsAddr = ''
+// once we're listening, report our IP:
+let ifaces = os.networkInterfaces()
+// this just logs the processes IP's to the termina
+Object.keys(ifaces).forEach(function(ifname) {
+  var alias = 0;
+
+  ifaces[ifname].forEach(function(iface) {
+    if ('IPv4' !== iface.family) { //} || iface.internal !== false) {
+      // skip over internal (i.e. 127.0.0.1) and non-ipv4 addresses
+      return;
+    }
+    if (alias >= 1) {
+      console.log('ip: ' /*ifname + ':' + alias,*/ + iface.address) // + `:${port}`);
+      // this single interface has multiple ipv4 addresses
+      // console.log('serving at: ' ifname + ':' + alias + iface.address + `:${port}`);
+    } else {
+      console.log('ip: ' /*ifname + ':' + alias,*/ + iface.address) //+ `:${port}`);
+      wsAddr = iface.address
+      // this interface has only one ipv4 adress
+      //console.log(ifname, iface.address);
+    }
+    ++alias;
+  });
+});
+
+let wsPort = 4040
+let errs = 0
+let startWSS = () => {
+  return new Promise((resolve, reject) => {
+    const wss = new WebSocketServer({ port: wsPort }, () => {
+      console.log(`OSAP-wss-addr: ws://${wsAddr}:${wsPort}`)
+    })
+    // each new connection gets a new socket,
+    wss.on('connection', (ws) => {
+      resolve(ws)
+    })
+    wss.on('error', (err) => {
+      if (err.code == "EADDRINUSE") {
+        console.log('ports in use, next...')
+        wsPort++
+        errs++
+        if (errs > 12) {
+          console.log('too many occupied ports, bailing')
+          process.exit()
+        } else {
+          return(startWSS())
+        }
+      } else {
+        console.log('exiting due to wss err', err)
+        process.exit()
+      }
+    })
+  })
+}
+
+export default {
+  start: startWSS
+}