From cbea9a6058532e9b881ddcac5fd951f770b5e0cd Mon Sep 17 00:00:00 2001
From: Christoph Willing <chris.willing@linux.com>
Date: Thu, 7 Sep 2017 09:54:05 +1000
Subject: [PATCH] Initial iSpindel support

---
 Makefile                               |   1 +
 src/scripts/modules/configuration.js   |  35 +-
 src/scripts/modules/fhem.js            | 222 ++++++++++++
 src/scripts/modules/gpioworker.js      |  42 ++-
 src/scripts/modules/requestHandlers.js |  15 +-
 src/scripts/status.js                  | 457 ++++++++++++++++++++++++-
 styles/brewable.css                    |  77 ++++-
 test-status.js                         | 134 --------
 8 files changed, 812 insertions(+), 171 deletions(-)
 create mode 100644 src/scripts/modules/fhem.js
 delete mode 100644 test-status.js

diff --git a/Makefile b/Makefile
index 88da79c..97d365b 100644
--- a/Makefile
+++ b/Makefile
@@ -16,6 +16,7 @@ SERVER_FILES = \
 	src/scripts/modules/server.js
 
 CLIENT_FILES = \
+	styles/brewable.css \
 	src/scripts/status.js \
 
 TEST_FILES = test-status.js \
diff --git a/src/scripts/modules/configuration.js b/src/scripts/modules/configuration.js
index f494343..8fcaec1 100644
--- a/src/scripts/modules/configuration.js
+++ b/src/scripts/modules/configuration.js
@@ -10,12 +10,9 @@ var defaultConfigValues = function() {
     'multiSensorMeanWeight' : parseInt(50),
     'relayDelayPostON'      : parseInt(180),
     'relayDelayPostOFF'     : parseInt(480),
-    'iSpindelA'             : {
-      "name":"iSpindel",
-      "calfactor0":0.00438551,
-      "calfactor1":0.13647658,
-      "calfactor2":6.968821422
-    }
+    'iSpindels'             : [
+      { "name":"iSpindel", "timeout":60 }
+    ]
   };
 };
 
@@ -59,6 +56,7 @@ Configuration.prototype.loadConfigFromFile = function () {
   console.log("conf file: " + path.join(this._projectConfigDir, this._project + ".conf"));
   try {
     this._configuration = JSON.parse(fs.readFileSync(this._configFileName, 'utf8'));
+    console.log("config from file: " + JSON.stringify(this._configuration));
   }
   catch (err) {
     console.log("Error reading " + this._configFileName + ". Using default configuration");
@@ -183,6 +181,31 @@ Configuration.prototype.setFudgeFactor = function (key, val) {
   fs.writeFileSync(this._configFileName, JSON.stringify(config));
 };
 
+Configuration.prototype.setIspindelTimeout = function (key, val) {
+  console.log("setIspindelTimeout() " + key + ", val " + val);
+
+  var config = this._configuration;
+  var found = false;
+  config.iSpindels.forEach( function(item) {
+    if (item.name == key ) {
+      found = true;
+      item.timeout = val;
+    }
+  });
+  if (!found) {
+    config.iSpindels.push({"name":key, "timeout":val});
+  }
+  fs.writeFileSync(this._configFileName, JSON.stringify(config));
+};
+
+Configuration.prototype.newIspindel = function (name) {
+  var config = this._configuration;
+  var defaultTimeout = defaultConfigValues().iSpindels[0].timeout;
+  config.iSpindels.push({"name":name, "timeout":defaultTimeout});
+  fs.writeFileSync(this._configFileName, JSON.stringify(config));
+  this.loadConfigFromFile();
+};
+
 /********
 atest = new Configuration();
 var config = atest.getConfiguration();
diff --git a/src/scripts/modules/fhem.js b/src/scripts/modules/fhem.js
new file mode 100644
index 0000000..e38217c
--- /dev/null
+++ b/src/scripts/modules/fhem.js
@@ -0,0 +1,222 @@
+/*
+  The only communication from an iSpindel device is its periodic data report.
+  We have no way of determining whether an iSpindel device is being used
+  (or multiple devices) other than the data reports. We therefore start out
+  assuming there are no iSPindel devices. As each device submits a data report,
+  we instantiate an fhemDevice object and add it to fhemDeviceList.
+
+  The fhemDevice object maintains a record of the last received data report
+  along with the time it was received. If we haven't heard from a device for
+  some predermined time, it is removed from fhemDeviceList by deviceReaper()
+  which runs periodically (started when the first iSpindel is detected).
+
+  Data reports are not frequent - the isPindel documentation mentions:
+    "With an update interval of 30min it was possible to achive a
+    battery lifetime of almost 3 months!" (sic).
+  Therefore when each data report is received, we emit "fhem_reading" so that
+  any interested modules can immediately do something with the newly received
+  data.
+*/
+import querystring from "querystring";
+import { eventEmitter } from "./gpioworker";
+import Configuration from "./configuration";
+
+
+/*
+  FHEM arithmetic from
+  https://github.com/universam1/iSpindel/blob/master/docs/upload-FHEM_en.md
+*/
+var correctPlato = function (plato, temp) {
+  var k;
+
+  if (plato < 5)         k = [56.084,    -0.17885,   -0.13063];
+  else if (plato >= 5)   k = [69.685,    -1.367,     -0.10621];
+  else if (plato >= 10)  k = [77.782,    -1.7288,    -0.10822];
+  else if (plato >= 15)  k = [87.895,    -2.3601,    -0.10285];
+  else if (plato >= 20)  k = [97.052,    -2.7729,    -0.10596];
+
+  var cPlato = k[0] + k[1] * temp + k[2] * temp*temp;
+  return plato - cPlato/100;
+};
+var calcPlato = function (tilt, temp) {
+  // Get this from Excel Calibration at 20 Degrees
+  var plato=0.00438551*tilt*tilt + 0.13647658*tilt - 6.968821422;
+
+  return correctPlato(plato, temp);
+};
+
+var fhemDeviceList = [];
+var searchDeviceListByName = function (name) {
+  var result;
+  for (var i=0;i<fhemDeviceList.length;i++) {
+    if (fhemDeviceList[i].name == name) {
+      return fhemDeviceList[i];
+    }
+  }
+  return result;
+};
+
+class fhemDevice {
+  constructor (raw) {
+    console.log("Creating new fhemDevice object from: " + JSON.stringify(raw));
+    this.raw = raw;
+    this.name = raw.name;
+    this.date = new Date();
+
+    // Check for existing configuration
+    var configObj = new Configuration();
+    var config = configObj.getConfiguration();
+    console.log("Configurations: " + JSON.stringify(config));
+    console.log("Configurations: " + Object.keys(config));
+    console.log("Configurations: " + Object.keys(config.iSpindels));
+
+    this.timeout;
+    for (var i=0;i<config.iSpindels.length;i++) {
+      console.log("Comparing " + config.iSpindels[i].name + " vs. " + raw.name);
+      if (config.iSpindels[i].name == raw.name) {
+        this.timeout = 1000 * parseInt(config.iSpindels[i].timeout);
+        console.log("Comparing was OK");
+        break;
+      }
+    }
+    if (! this.timeout) {
+      // No timeout from configuration so need to make one up
+      // We expect reports (at least) every 30mins,
+      // so a check every 10mins chould be plenty.
+      // 10 * 60 * 1000 = 600000
+      configObj.newIspindel(raw.name);
+      this.timeout = raw.timeout || 600000;
+      console.log("Couldn't find " + raw.name + ". Using default timeout (" + (this.timeout/1000) + "s).");
+    }
+
+    // Periodically check whether to remove this device
+    this.reaper = setInterval(this.deviceReaper,parseInt(this.timeout/10),this);
+  }
+
+  static newReading (reading) {
+    //console.log("New reading: " + reading);
+    var obj = {};
+
+    try {
+      var parsed = querystring.parse(reading);
+      //console.log("= " + JSON.stringify(parsed));
+
+      var command = parsed["cmd.Test"].split(" ");
+      //console.log("command = " + command);
+    } catch (err) {
+      console.log("newReading() Can't parse " + reading);
+      return;
+    }
+
+    if (command.length != 6 ) {
+      console.log("newReading() Incorrect element count while parsing object: " + JSON.stringify(command));
+      return;
+    }
+    obj.name = command[1];
+    obj.tilt = parseFloat(command[2]);
+    obj.temp = parseFloat(command[3]);
+    obj.batt = parseFloat(command[4]);
+    obj.grav = parseFloat(command[5]);
+    obj.plato = calcPlato(obj.tilt, obj.temp);
+
+    var device = searchDeviceListByName(obj.name);
+    if (device) {
+      console.log("Already have device: " + device.name + " at " + device.stamp);
+      device.update(obj);
+    } else {
+      console.log("Adding new device");
+      fhemDeviceList.push(new fhemDevice(obj));
+    }
+
+    eventEmitter.emit("fhem_reading", obj);
+  }
+
+  update (raw) {
+    this.raw = raw;
+    this.name = raw.name;
+    this.date = new Date();
+  }
+
+  static devices () {
+    return fhemDeviceList;
+  }
+
+  get stamp () {
+    return this.date;
+  }
+
+  get tilt () {
+    return this.raw.tilt;
+  }
+  get temp () {
+    return this.raw.temp;
+  }
+  get batt () {
+    return this.raw.batt;
+  }
+  get grav () {
+    return this.raw.grav;
+  }
+  get plato () {
+    return calcPlato(this.raw.tilt, this.raw.temp);
+  }
+
+  /*
+    If the device is in the first x% of its life (time to be reaped)
+    then fresh is true, otherwise false
+  */
+  get fresh () {
+    var device = searchDeviceListByName(this.name);
+    if (! device) return false;
+
+    if ((new Date() - new Date(device.stamp)) < parseInt(device.timeout/5) ) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /* val seconds */
+  setNewTimeout (val) {
+    var newTimeout = parseInt(val);
+    if (newTimeout < 10) return;
+    this.timeout = 1000 * newTimeout;
+    if (this.reaper) clearInterval(this.reaper);
+
+    this.reaper = setInterval(this.deviceReaper, this.timeout/10, this);
+  }
+
+  /*
+    We expect reports (at least) every 30mins,
+    so if nothing heard from a device for twice that time, remove it.
+    60 * 60 * 1000 = 3600000
+  */
+  deviceReaper (caller) {
+    //console.log("Reaping ... fhemDeviceList length = " + fhemDeviceList.length);
+    var reap = false;
+    var i;
+    for (i=0;i<fhemDeviceList.length;i++) {
+      if (fhemDeviceList[i].name == caller.name ) {
+        //console.log("dur: " + (new Date() - new Date(fhemDeviceList[i].stamp)));
+        //console.log("timeout = " + caller.timeout);
+        if ((new Date() - new Date(fhemDeviceList[i].stamp)) > caller.timeout ) {
+          console.log("Planning removal of " + fhemDeviceList[i].name + ", caller = " + caller.name);
+          reap = true;
+        }
+        break;
+      }
+    }
+    if (reap ) {
+      console.log("Removing " + fhemDeviceList[i].name + ", caller = " + caller.name);
+      clearInterval(caller.reaper);
+      fhemDeviceList.splice(i, 1);
+    }
+  }
+
+}
+
+export default fhemDevice;
+export const newReading = fhemDevice.newReading;
+
+/* ex:set ai shiftwidth=2 inputtab=spaces smarttab noautotab: */
+
diff --git a/src/scripts/modules/gpioworker.js b/src/scripts/modules/gpioworker.js
index 65a8984..81e2523 100644
--- a/src/scripts/modules/gpioworker.js
+++ b/src/scripts/modules/gpioworker.js
@@ -6,6 +6,7 @@ import events from "events";
 var eventEmitter = new events.EventEmitter();
 
 import SensorDevice from "./sensor";
+import fhemDevice from "./fhem";
 import Relay from "./sainsmartrelay";
 import Configuration from "./configuration";
 import JobProcessor from "./jobprocessor";
@@ -133,16 +134,20 @@ function gpioWorker (input_queue, output_queue) {
 //export default gpioWorker;
 export { gpioWorker, eventEmitter };
 
+/*
+  Just for testing.
+  We should really just call liveUpdate which should extract data from
+  any/all devices (including the one whose data report triggered the
+  'fhem_reading' event which is probably what brought us here.
+*/
 gpioWorker.prototype.fhemReading = function (reading) {
   //console.log("fhemReading() " + JSON.stringify(reading));
   var name = reading.name;
   var tilt = reading.tilt;
   var temp = reading.temp;
   var batt = reading.batt;
-  console.log("fhem() " + name + ", " + tilt + ", " + temp + ", " + batt);
-
-  //var plato = calcPlato(tilt, temp);
-  //console.log("plato = " + plato);
+  var grav = reading.grav;
+  console.log("fhemReading() " + name + ", " + tilt + ", " + temp + ", " + batt + ", " + grav);
 };
 
 gpioWorker.prototype.sensorDevices = function () {
@@ -161,6 +166,7 @@ gpioWorker.prototype.sensorDevices = function () {
     var bval = parseInt(b.id.substr(0,b.id.search("-")),16) + parseInt(b.id.substr(b.id.search("-") + 1),16);
     return aval - bval;
   });
+  console.log("deviceList = " + JSON.stringify(deviceList));
   return deviceList;
 };
 
@@ -214,6 +220,15 @@ gpioWorker.prototype.liveUpdate = function () {
   });
   //console.log("liveUpdate(): " + JSON.stringify(sensor_state));
 
+  var fhemDevices = fhemDevice.devices();
+  fhemDevices.forEach( function (item) {
+    if (item.fresh) {
+      console.log("FHEM device: " + item.name + ", " + item.stamp);
+      sensor_state.push({'sensorId':item.name, 'temperature':item.temp, 'tilt':item.tilt, 'batt':item.batt, 'grav':item.grav, 'stamp':item.stamp});
+    }
+  });
+  //console.log("liveUpdate(): " + JSON.stringify(sensor_state));
+
   for (var i=0;i<this.relay.deviceCount();i++) {
     relay_state.push([this.relay.isOn(i+1), this.relay.isDelayed(i+1)]);
   }
@@ -297,12 +312,13 @@ gpioWorker.prototype.processMessage = function () {
 
 gpioWorker.prototype.load_startup_data = function (msg) {
   //console.log("load_startup_data():");
+  var configObj = new Configuration();
 
   var jdata = JSON.stringify({
     'type':'startup_data',
     'data': {
       'testing': this.brewtest(),
-      'config' : this.configObj.getConfiguration(),
+      'config' : configObj.getConfiguration(),
       'the_end': 'orange'
     }
   });
@@ -338,6 +354,22 @@ gpioWorker.prototype.config_change = function (msg) {
     });
     //this.configuration.sensorFudgeFactors[msg.data['sensorFudgeFactors']] = msg.data['fudge'];
     this.configObj.setFudgeFactor(msg.data['sensorFudgeFactors'], msg.data['fudge']);
+  } else if (keys[0] == 'iSpindels') {
+    console.log("config_change() iSpindels: "  + msg.data['iSpindels'] + " (" + msg.data['timeout'] + ")");
+
+    // First update the configuration
+    this.configObj.setIspindelTimeout(msg.data['iSpindels'], msg.data['timeout']);
+
+    // Now apply to the device itself
+    var fhemDevices = fhemDevice.devices();
+    fhemDevices.forEach( function (item) {
+      console.log("reconfig FHEM device: " + item.name + ", " + item.stamp);
+      if (item.name == msg.data['iSpindels']) {
+        console.log("Found the right one:" + item.name);
+        item.setNewTimeout(msg.data['timeout']);
+      }
+    });
+
   } else if (keys[0] == 'multiSensorMeanWeight') {
     this.configObj.setMultiSensorMeanWeight(msg.data['multiSensorMeanWeight']);
   } else if (keys[0] == 'relayDelayPostON' || keys[0] == 'relayDelayPostOFF') {
diff --git a/src/scripts/modules/requestHandlers.js b/src/scripts/modules/requestHandlers.js
index 207b2ee..ac23cbe 100644
--- a/src/scripts/modules/requestHandlers.js
+++ b/src/scripts/modules/requestHandlers.js
@@ -32,7 +32,7 @@ function favicon(response) {
       response.writeHead(404);
       response.write("Not Found!");
     } else {
-      response.writeHead(200, {"Content-Type": "image/x-icon"});
+      response.writeHead(200, {"Content-Type": "text/plain"});
       response.write(data);
     }
     response.end();
@@ -42,18 +42,7 @@ function favicon(response) {
 function fhem(response, query) {
   console.log("Request handler 'fhem' was called with query: " + query);
   newReading(query);
-  /*
-  fs.readFile(path.join(__dirname, "../../../favicon.ico"), function (err, data) {
-    if(err){
-      response.writeHead(404);
-      response.write("Not Found!");
-    } else {
-      response.writeHead(200, {"Content-Type": "image/x-icon"});
-      response.write(data);
-    }
-    response.end();
-  });
-  */
+  response.writeHead(200, {"Content-Type": "image/x-icon"});
   response.end();
 }
 
diff --git a/src/scripts/status.js b/src/scripts/status.js
index 8acf45a..30b1d15 100644
--- a/src/scripts/status.js
+++ b/src/scripts/status.js
@@ -20,6 +20,8 @@ var global_x = 0;
 
 var availableSensors = [];
 var availableRelays  = [];
+var iSpindelDevices = [];
+var iSpindelWaitTimes = {};
 
 var profileData = [];
 var profileDisplayData = [];        // "processed" data for display
@@ -122,6 +124,282 @@ if (!String.prototype.padStart) {
   };
 }
 
+/**
+* From https://stackoverflow.com/questions/8211744/convert-time-interval-given-in-seconds-into-more-human-readable-form
+*
+* Translates seconds into human readable format of seconds, minutes, hours, days, and years
+* 
+* @param  {number} seconds The number of seconds to be processed
+* @return {string}         The phrase describing the the amount of time
+*/
+function forHumans ( seconds ) {
+  var levels = [
+    [Math.floor(seconds / 31536000), 'Y'], /* years */
+    [Math.floor((seconds % 31536000) / 86400), 'd'], /*days */
+    [Math.floor(((seconds % 31536000) % 86400) / 3600), 'h'], /*hours*/
+    [Math.floor((((seconds % 31536000) % 86400) % 3600) / 60), 'm'], /*mins*/
+    [(((seconds % 31536000) % 86400) % 3600) % 60, 's'], /* seconds */
+  ];
+  var returntext = '';
+
+  for (var i = 0, max = levels.length; i < max; i++) {
+    if ( levels[i][0] === 0 ) continue;
+    returntext += ' ' + levels[i][0] + ' ' + (levels[i][0] === 1 ? levels[i][1].substr(0, levels[i][1].length-1): levels[i][1]);
+  }
+  return returntext.trim();
+} 
+
+
+class Ispindel {
+  constructor (report, parent) {
+    this.name = report.sensorId;
+    this.tilt = report.tilt;
+    this.temp = report.temperature;
+    this.grav = report.grav;
+    //this.plato = report.plato;
+    this.batt = report.batt;
+    this.stamp = report.stamp;
+    this.parent = parent;
+    this.elementName = 'sensor_update_' + this.name;
+
+    // How long to wait (ms) after last report before removing this device
+    // 61 * 60 * 1000 = 3660000 (61 minutes)
+    var defaultWaitTime = 60000;     // 60000 = 1min
+    //if (iSpindelWaitTimes[report.sensorId]) {
+    console.log("iSpindelWaitTimes has keys: " + JSON.stringify(Object.keys(iSpindelWaitTimes)));
+    console.log("iSpindelWaitTimes has " + JSON.stringify(iSpindelWaitTimes));
+    console.log("report.sensorId = " + report.sensorId);
+    console.log("waitTime should be = " + iSpindelWaitTimes[report.sensorId]);
+    this.waitTime = 1000 * iSpindelWaitTimes[report.sensorId] || defaultWaitTime;
+
+    var isp_temp, isp_tilt, isp_grav, isp_batt, isp_stamp;
+
+    isp_tilt = document.createElement("DIV");
+    isp_tilt.id = this.elementName + "_tilt";
+    isp_tilt.className = "isp_entry";
+    this.parent.appendChild(isp_tilt);
+
+    isp_temp = document.createElement("DIV");
+    isp_temp.id = this.elementName + "_temp";
+    isp_temp.className = "isp_entry";
+    this.parent.appendChild(isp_temp);
+
+    isp_grav = document.createElement("DIV");
+    isp_grav.id = this.elementName + "_grav";
+    isp_grav.className = "isp_entry";
+    this.parent.appendChild(isp_grav);
+
+    this.ispindelUpdateInterval = setInterval(this.checkIspindelTimeout, 1000, this);
+    console.log("A new Ispindel device for " + this.parent.id);
+  }
+
+  set_contents (state, tempScale) {
+
+    this.temp = state.temperature;
+    if (tempScale == 'F') {
+      document.getElementById(this.elementName + "_temp").textContent = ((state.temperature * 9 / 5 ) + 32).toFixed(2);
+    } else {
+      document.getElementById(this.elementName + "_temp").textContent = (state.temperature).toFixed(2);
+    }
+    this.grav = state.grav;
+    document.getElementById(this.elementName + "_grav").textContent = (state.grav).toFixed(2);
+    this.tilt = state.tilt;
+    document.getElementById(this.elementName + "_tilt").textContent = (state.tilt).toFixed(2);
+    this.batt = state.batt;
+
+    this.stamp = state.stamp;
+
+  }
+
+  setNewWaitTime(val) {
+    console.log("Setting new timeout (" + val + ") for " + this.name);
+
+    var newWaitTime = parseInt(val);
+    if (newWaitTime < 10) return;
+    this.waitTime = 1000 * newWaitTime;
+  }
+
+  checkIspindelTimeout(ispindel) {
+    console.log("Checking iSpindel timeout " + ispindel.waitTime);
+
+    var elapsed = new Date() - new Date(ispindel.stamp);
+    if (elapsed > ispindel.waitTime ) {
+      clearInterval(ispindel.ispindelUpdateInterval);
+      console.log("Toooo long since last report");
+      ispindel.removeOverlay();
+      var x = document.getElementById(ispindel.elementName);
+      if (x) x.parentNode.removeChild(x);
+
+      var itemToRemove = -1;
+      iSpindelDevices.forEach( function (item, index) {
+        if (item.name == ispindel.name) {
+          itemToRemove = index;
+        }
+      });
+      console.log("Removing item " + itemToRemove + " from " + JSON.stringify(iSpindelDevices));
+      if (itemToRemove > -1 ) iSpindelDevices.splice(itemToRemove,1);
+      console.log("Changed iSpindelDevices: " + JSON.stringify(iSpindelDevices));
+      return;
+    }
+  }
+
+  showOverlay () {
+    var el = document.getElementById(this.elementName);
+
+    // Size of enclosing DIV (css isp_sensor_update)
+    var els = {"w":128, "h":64};
+    // Size of overlay (css .isp_sol)
+    var ols = {"w":168, "h":152};
+
+    this.overlay = document.createElement("DIV");
+    this.overlay.id = this.elementName + "_overlay";
+    this.overlay.className = "isp_sol unselectable";
+    this.overlay.style.position = "fixed";
+    this.overlay.style.top = getOffsetRect(el).top - (ols.h - els.h)/2 + 'px';
+    this.overlay.style.left = getOffsetRect(el).left - (ols.w - els.w)/2 + 'px';
+    document.body.appendChild(this.overlay);
+
+    // Overlay contents
+    var olTitle = document.createElement("DIV");
+    olTitle.id = this.elementName + "_overlay_title";
+    olTitle.className = "isp_sol_title unselectable";
+    olTitle.textContent = this.name;
+    this.overlay.appendChild(olTitle);
+
+    var olTilt = document.createElement("DIV");
+    olTilt.id = this.elementName + "_overlay_tilt";
+    olTilt.className = "isp_sol_detail unselectable";
+    var olTiltKey = document.createElement("DIV");
+    olTiltKey.id = this.elementName + "_overlay_tilt_key";
+    olTiltKey.className = "isp_sol_key unselectable";
+    olTiltKey.textContent = "Tilt:";
+    var olTiltVal = document.createElement("DIV");
+    olTiltVal.id = this.elementName + "_overlay_tilt_val";
+    olTiltVal.className = "isp_sol_val unselectable";
+    olTiltVal.textContent = this.tilt + "\u00B0";
+    olTilt.appendChild(olTiltKey);
+    olTilt.appendChild(olTiltVal);
+    this.overlay.appendChild(olTilt);
+
+    var olTemp = document.createElement("DIV");
+    olTemp.id = this.elementName + "_overlay_temp";
+    olTemp.className = "isp_sol_detail unselectable";
+    var olTempKey = document.createElement("DIV");
+    olTempKey.id = this.elementName + "_overlay_temp_key";
+    olTempKey.className = "isp_sol_key unselectable";
+    olTempKey.textContent = "Temp:";
+    var olTempVal = document.createElement("DIV");
+    olTempVal.id = this.elementName + "_overlay_temp_val";
+    olTempVal.className = "isp_sol_val unselectable";
+    olTempVal.textContent = this.temp + "\u00B0";
+    olTemp.appendChild(olTempKey);
+    olTemp.appendChild(olTempVal);
+    this.overlay.appendChild(olTemp);
+
+    var olGrav = document.createElement("DIV");
+    olGrav.id = this.elementName + "_overlay_grav";
+    olGrav.className = "isp_sol_detail unselectable";
+    var olGravKey = document.createElement("DIV");
+    olGravKey.id = this.elementName + "_overlay_grav_key";
+    olGravKey.className = "isp_sol_key unselectable";
+    olGravKey.textContent = "Grav:";
+    var olGravVal = document.createElement("DIV");
+    olGravVal.id = this.elementName + "_overlay_grav_val";
+    olGravVal.className = "isp_sol_val unselectable";
+    olGravVal.textContent = this.grav.toFixed(2);
+    olGrav.appendChild(olGravKey);
+    olGrav.appendChild(olGravVal);
+    this.overlay.appendChild(olGrav);
+
+    /*
+    var olPlato = document.createElement("DIV");
+    olPlato.id = this.elementName + "_overlay_plato";
+    olPlato.className = "isp_sol_detail unselectable";
+    var olPlatoKey = document.createElement("DIV");
+    olPlatoKey.id = this.elementName + "_overlay_plato_key";
+    olPlatoKey.className = "isp_sol_key unselectable";
+    olPlatoKey.textContent = "Plato:";
+    var olPlatoVal = document.createElement("DIV");
+    olPlatoVal.id = this.elementName + "_overlay_plato_val";
+    olPlatoVal.className = "isp_sol_val unselectable";
+    olPlatoVal.textContent = this.plato.toFixed(2);
+    olPlato.appendChild(olPlatoKey);
+    olPlato.appendChild(olPlatoVal);
+    this.overlay.appendChild(olPlato);
+    */
+
+    var olBatt = document.createElement("DIV");
+    olBatt.id = this.elementName + "_overlay_batt";
+    olBatt.className = "isp_sol_detail unselectable";
+    var olBattKey = document.createElement("DIV");
+    olBattKey.id = this.elementName + "_overlay_batt_key";
+    olBattKey.className = "isp_sol_key unselectable";
+    olBattKey.textContent = "Batt:";
+    var olBattVal = document.createElement("DIV");
+    olBattVal.id = this.elementName + "_overlay_batt_val";
+    olBattVal.className = "isp_sol_val unselectable";
+    olBattVal.textContent = this.batt + "v";
+    olBatt.appendChild(olBattKey);
+    olBatt.appendChild(olBattVal);
+    this.overlay.appendChild(olBatt);
+
+    var olLast = document.createElement("DIV");
+    olLast.id = this.elementName + "_overlay_last";
+    olLast.className = "isp_sol_detail unselectable";
+    var olLastKey = document.createElement("DIV");
+    olLastKey.id = this.elementName + "_overlay_last_key";
+    olLastKey.className = "isp_sol_key unselectable";
+    olLastKey.textContent = "Last:";
+    var olLastVal = document.createElement("DIV");
+    olLastVal.id = this.elementName + "_overlay_last_val";
+    olLastVal.className = "isp_sol_val unselectable";
+    olLastVal.textContent = forHumans(parseInt((new Date() - new Date(this.stamp))/1000));
+    olLast.appendChild(olLastKey);
+    olLast.appendChild(olLastVal);
+    this.overlay.appendChild(olLast);
+
+    this.overlayUpdateInterval = setInterval(this.checkOverlayTimeout, 1000, this);
+
+    this.overlay.addEventListener("mouseout", function () {
+      this.removeOverlay();
+    }.bind(this));
+
+    this.overlay.addEventListener("dblclick", function (e) {
+      console.log("Pressed button " + e.button + " at " + this.name);
+      this.configureIspindel(this);
+    }.bind(this));
+
+  }
+
+  configureIspindel (ispindel) {
+    console.log("configureIspindel() " + ispindel.name);
+    ispindel.removeOverlay();
+    location.href = '#content_4';
+  }
+
+  checkOverlayTimeout (ispindel) {
+    //console.log("checkOverlayTimeout() " + ispindel.stamp);
+
+    var elapsed = new Date() - new Date(ispindel.stamp);
+    if (elapsed > ispindel.waitTime ) {
+      console.log("Too long since last report");
+      ispindel.removeOverlay();
+      var x = document.getElementById(ispindel.elementName);
+      if (x) x.parentNode.removeChild(x);
+      return;
+    }
+
+    var olLastVal = document.getElementById(ispindel.elementName + "_overlay_last_val");
+    if (olLastVal) {
+      olLastVal.textContent = forHumans(parseInt((new Date() - new Date(ispindel.stamp))/1000));
+    }
+  }
+  removeOverlay () {
+    var x = document.getElementById(this.elementName + "_overlay");
+    if (x) document.body.removeChild(x);
+    if (this.overlayUpdateInterval) clearInterval(this.overlayUpdateInterval);
+  }
+}
 
 // main()
 //domReady( function(){
@@ -546,6 +824,7 @@ window.onload = function () {
     socket.send(message.data);
   };
 
+ 
   function live_update(data) {
     var sensor_state = data.sensor_state;
     var relay_state = data.relay_state;
@@ -583,6 +862,8 @@ window.onload = function () {
     var tempScale = el.getAttribute('tempScale');
     el.textContent = 'Temp. (' + tempScale + '):';
 
+    var isp;
+    var existingIspNames;
     for (i=0;i<sensor_state.length;i++) {
       //console.log("sensor_state: " + sensor_state[i].sensorId + " = " + sensor_state[i].temperature);
       elementName = 'sensor_update_' + sensor_state[i].sensorId;
@@ -590,20 +871,53 @@ window.onload = function () {
         sensor_updateHolder = document.getElementById('sensor_updateHolder');
         asensor = document.createElement("DIV");
         asensor.id = elementName;
-        asensor.title = sensor_state[i].sensorId;
-        asensor.className = 'sensor_update';
-        asensor.style.width = '128px';
-        //asensor.oncontextmenu = function(e) { return false; };
         asensor.oncontextmenu = function() { return false; };
-        asensor.onmousedown = function(e) {
-          console.log("Pressed button " + e.button + " at " + this.id);
-        };
+        existingIspNames = [];
+        if (sensor_state[i].tilt) {
+          //console.log("We have an iSpindel!");
+          asensor.className = 'isp_sensor_update';
+          for (var ispi=0;ispi<iSpindelDevices.length;ispi++) {
+            console.log("checking: " + sensor_state[i].name + " vs. " + iSpindelDevices[ispi].name);
+            if (sensor_state[i].name == iSpindelDevices[ispi].name) {
+              existingIspNames.push(sensor_state[i].name);
+            }
+          }
+          console.log("Already have: " + JSON.stringify(existingIspNames));
+          console.log("iSpindelDevices was: " + JSON.stringify(iSpindelDevices));
+          if (! (sensor_state[i].name in existingIspNames)) {
+            isp = new Ispindel(sensor_state[i], asensor);
+            iSpindelDevices.push(isp);
+            addIspindelConfigData({data:{"name":isp.name,"timeout":parseInt(isp.waitTime/1000)}});
+          }
+          console.log("iSpindelDevices now: " + JSON.stringify(iSpindelDevices));
+          asensor.onmouseover = function(e) {
+            isp.showOverlay(e);
+          };
+        } else {
+          asensor.className = 'sensor_update';
+          asensor.title = sensor_state[i].sensorId;
+          asensor.onmousedown = function(e) {
+            console.log("Pressed button " + e.button + " at " + this.id);
+          };
+        }
         sensor_updateHolder.appendChild(asensor);
       }
-      if (tempScale == 'F') {
-        document.getElementById(elementName).textContent = ((parseFloat(sensor_state[i].temperature) * 9 / 5 ) + 32).toFixed(2);
+      if (sensor_state[i].tilt) {
+        isp = undefined;
+        for (var j=0;j<iSpindelDevices.length;j++) {
+          //console.log(iSpindelDevices[j].name + ", " + sensor_state[i].sensorId);
+          if (iSpindelDevices[j].name == sensor_state[i].sensorId) {
+            isp = iSpindelDevices[j];
+            break;
+          }
+        }
+        if(isp) isp.set_contents(sensor_state[i], tempScale);
       } else {
-        document.getElementById(elementName).textContent = (sensor_state[i].temperature).toFixed(2);
+        if (tempScale == 'F') {
+          document.getElementById(elementName).textContent = ((parseFloat(sensor_state[i].temperature) * 9 / 5 ) + 32).toFixed(2);
+        } else {
+          document.getElementById(elementName).textContent = (sensor_state[i].temperature).toFixed(2);
+        }
       }
     }
     // Set width of bounding box
@@ -811,6 +1125,72 @@ window.onload = function () {
     }
   }
 
+  /*
+    Ispindel config data can come from saved data
+    or from new instances appearing on the network.
+  */
+  function addIspindelConfigData(passedArgs) {
+    var isp_sensor = passedArgs.data;
+    var configItemData = passedArgs.branch || document.getElementById("configItemData_iSpindels");
+    console.log("addIspindelConfigData() args: " + JSON.stringify(passedArgs));
+
+    iSpindelWaitTimes[isp_sensor.name] = parseInt(isp_sensor.timeout);
+
+    if (configItemData.querySelector("#configItemDataValue_" + isp_sensor.name)) {
+      console.log("Already have #configItemDataValue_" + isp_sensor.name);
+      return;
+    }
+    var configItemDataValue = document.createElement('DIV');
+    configItemDataValue.id = 'configItemDataValue_' + isp_sensor.name;
+    configItemDataValue.className = 'configItemDataValue';
+
+    var configItemSensorName = document.createElement('DIV');
+    configItemSensorName.id = 'configItemSensorName_' + isp_sensor.name;
+    configItemSensorName.className = 'configItemSensorName';
+    configItemSensorName.textContent = isp_sensor.name;
+    var configItemSensorIspindel = document.createElement('INPUT');
+    configItemSensorIspindel.id = 'configItemSensorIspindel_' + isp_sensor.name;
+    configItemSensorIspindel.className = 'configItemSensorIspindel';
+    configItemSensorIspindel.setAttribute('type', 'text');
+    configItemSensorIspindel.value = isp_sensor.timeout;
+
+    // Let server know about it
+    msgobj = {
+      type:'config_change',
+      data:{
+        'iSpindels':isp_sensor.name,
+        'timeout':isp_sensor.timeout
+      }
+    };
+    sendMessage({data:JSON.stringify(msgobj)});
+
+    configItemSensorIspindel.onblur = function () {
+      console.log("key: " + this.id + "  " + this.id.replace(/.+_/,''));
+      var idata = {};
+      idata['iSpindels'] = this.id.substring(this.id.indexOf("_") + 1);
+      idata['timeout'] = this.value;
+      msgobj = {type:'config_change', data:idata};
+      sendMessage({data:JSON.stringify(msgobj)});
+
+      // Apply to local instances
+      iSpindelWaitTimes[idata['iSpindels']] = idata['timeout'];
+      console.log("Set: " + JSON.stringify(iSpindelWaitTimes));
+      console.log("Have " + iSpindelDevices.length + " iSpindelDevices to reconfigure");
+      iSpindelDevices.forEach( function (item) {
+        console.log("name " + item.name);
+        if (item.name == idata['iSpindels']) {
+          console.log("Found " + item.name);
+          item.setNewWaitTime(idata['timeout']);
+        }
+      });
+    };
+
+
+    configItemDataValue.appendChild(configItemSensorName);
+    configItemDataValue.appendChild(configItemSensorIspindel);
+    configItemData.appendChild(configItemDataValue);
+  }
+
   function build_config_entries(configItems) {
     var configEntryHolder = document.getElementById('configEntryHolder');
     for (var key in configItems) {
@@ -858,6 +1238,63 @@ window.onload = function () {
           configItemDataValue.appendChild(configItemSensorFudge);
           configItemData.appendChild(configItemDataValue);
         }
+      } else if (key == "iSpindels") {
+        console.log("Configure ISpindels");
+        var isp_sensor;
+        for (var i in configItems[key]) {
+          isp_sensor = configItems[key][i];
+          console.log("isp: " + JSON.stringify(isp_sensor));
+          addIspindelConfigData({"branch":configItemData, "data":isp_sensor});
+
+          /*
+          iSpindelWaitTimes[isp_sensor.name] = parseInt(isp_sensor.timeout);
+
+          configItemDataValue = document.createElement('DIV');
+          configItemDataValue.id = 'configItemDataValue_' + isp_sensor.name;
+          configItemDataValue.className = 'configItemDataValue';
+
+          configItemSensorName = document.createElement('DIV');
+          configItemSensorName.id = 'configItemSensorName_' + isp_sensor.name;
+          configItemSensorName.className = 'configItemSensorName';
+          configItemSensorName.textContent = isp_sensor.name;
+          var configItemSensorIspindel = document.createElement('INPUT');
+          configItemSensorIspindel.id = 'configItemSensorIspindel_' + isp_sensor.name;
+          configItemSensorIspindel.className = 'configItemSensorIspindel';
+          configItemSensorIspindel.setAttribute('type', 'text');
+          configItemSensorIspindel.value = isp_sensor.timeout;
+          configItemSensorIspindel.onblur = function () {
+            console.log("key: " + this.id + "  " + this.id.replace(/.+_/,''));
+            var idata = {};
+            idata['iSpindels'] = this.id.substring(this.id.indexOf("_") + 1);
+            idata['timeout'] = this.value;
+            msgobj = {type:'config_change', data:idata};
+            sendMessage({data:JSON.stringify(msgobj)});
+
+            // Apply to local instances
+            iSpindelWaitTimes[idata['iSpindels']] = idata['timeout'];
+            console.log("Set: " + JSON.stringify(iSpindelWaitTimes));
+            console.log("Have " + iSpindelDevices.length + " iSpindelDevices to reconfigure");
+            iSpindelDevices.forEach( function (item) {
+              console.log("name " + item.name);
+              if (item.name == idata['iSpindels']) {
+                console.log("Found " + item.name);
+                item.setNewWaitTime(idata['timeout']);
+              }
+            });
+          };
+
+
+          configItemDataValue.appendChild(configItemSensorName);
+          configItemDataValue.appendChild(configItemSensorIspindel);
+          configItemData.appendChild(configItemDataValue);
+          */
+        }
+
+        configItemName.classList.add("unselectable");
+        configItemName.title = "Double click to configure new iSpindel device";
+        configItemName.addEventListener("dblclick", function() {
+          console.log("Add new iSpindel configuration");
+        });
       } else {
         configItemDataValue = document.createElement('DIV');
         configItemDataValue.id = 'configItemDataValue_' + key;
diff --git a/styles/brewable.css b/styles/brewable.css
index 58b0753..2074c6c 100644
--- a/styles/brewable.css
+++ b/styles/brewable.css
@@ -251,12 +251,83 @@ div#sensor_updateHolder {
 }
 .sensor_update {
     position:   relative;
+    width:	128px;
     height:	64px;
     line-height: 60px;
     float:	left;
     text-align: center;
 }
-div#relay_updateHolder {
+.isp_sensor_update {
+    display:    flex;
+    flex-direction: column;
+    alilgn-items: center;
+    justify-content: center;
+
+    display:    -webkit-flex;
+    -webkit-flex-direction: column;
+    -webkit-align-items:	center;
+    -webkit-justify-content:	center;
+
+    width:	128px;
+    height:	64px;
+}
+.isp_entry {
+    font-size: 100%;
+}
+/* isp_sensor_overlay */
+.isp_sol {
+    background-color: #000;
+    opacity:    .7;
+    /* filter: alpha(opacity=70); */
+    width:      168px;
+    height:	152;
+    z-index:    10;
+
+    border:	1px solid white;
+    border-radius: 4px;
+    color:      white;
+}
+/* isp_sensor_overlay_title */
+.isp_sol_title {
+    display:    flex;
+    alilgn-items: center;
+    justify-content: center;
+
+    display:    -webkit-flex;
+    -webkit-align-items:	center;
+    -webkit-justify-content:	center;
+
+    font-weight: bold;
+    font-size:  100%;
+    padding:	0.5em;
+}
+/* isp_sensor_overlay_detail */
+.isp_sol_detail {
+    display:    flex;
+    alilgn-items: center;
+    justify-content: center;
+
+    display:    -webkit-flex;
+    -webkit-align-items:	center;
+    -webkit-justify-content:	center;
+}
+.isp_sol_key {
+    display:    flex;
+    display:    -webkit-flex;
+
+    width:      32%;
+    padding-right: 12px;
+
+    justify-content: right;
+    -webkit-justify-content:	rlight;
+}
+.isp_sol_val {
+    display:    flex;
+    display:    -webkit-flex;
+
+    width:      68%;
+}
+#relay_updateHolder {
     display:    flex;
     align-items: center;
     justify-content: center;
@@ -988,11 +1059,11 @@ div#jobComposer {
     margin:     3px 10px;
     border:	2px solid #000;
 }
-.configItemDataValueInput,.configItemSensorFudge {
+.configItemDataValueInput,.configItemSensorFudge,.configItemSensorIspindel {
     width:      94%;
     text-align: center;
 }
-.configItemSensorFudge {
+.configItemSensorFudge,.configItemSensorIspindel {
     text-align: center;
 }
 .config_label {
diff --git a/test-status.js b/test-status.js
deleted file mode 100644
index c642f44..0000000
--- a/test-status.js
+++ /dev/null
@@ -1,134 +0,0 @@
-import { default as gpio } from './src/scripts/modules/jsogpio';
-
-console.log("pid=" + process.pid);
-
-var options = {};
-process.argv.forEach((val, index) => {
-  //console.log(`${index}: ${val}`);
-  if (val.indexOf('=') > -1) {
-    console.log("val: " + val);
-    var opt = val.split('=');
-    console.log("opt 0 : " + opt[0]);
-    console.log("opt 1 : " + opt[1]);
-    options[opt[0]] = opt[1];
-  }
-});
-console.log("raw options: " + process.argv);
-console.log("options: " + JSON.stringify(options));
-
-if ("port" in options) options.port = parseInt(options.port);
-console.log("options: " + JSON.stringify(options));
-
-class Rectangle {
-  constructor(height, width) {
-    this.height = height;
-    this.width = width;
-  }
-
-  get area() {
-    return this.height * this.width;
-  }
-
-  speak() {
-    console.log("I am not an animal");
-  }
-}
-
-var square = new Rectangle(10,10);
-console.log("Area = " + square.area);
-
-class Dog extends Rectangle {
-  constructor (w,h) {
-    super(w,h);
-  }
-  speak() {
-    super.speak();
-    console.log("Woof " + this.area);
-  }
-}
-var d = new Dog(5,5);
-d.speak();
-
-
-process.exit();
-
-/* Physical numbering */
-var PossibleRelayPins = [
-  12, 11, 13, 15,
-  16, 18, 19, 21,
-  22, 23, 32, 33,
-  36, 37, 38, 40
-];
-var PIN_NUMBERING_MODE = 'physical';
-
-var RELAY_ON  = gpio.LOW;
-var RELAY_OFF = gpio.HIGH;
-
-var RelayPins = {};
-
-
-function testConnected () {
-  var pins = [];
-  for (var x in RelayPins) {pins.push(RelayPins[x]);}
-  pins.forEach(function (item) {
-    //console.log("RRRR " + item)
-    gpio.open(item, gpio.OUTPUT, RELAY_OFF);
-    gpio.write(item, RELAY_ON);
-    gpio.msleep(500);
-    gpio.write(item, RELAY_OFF);
-    gpio.close(item);
-    gpio.msleep(200);
-  });
-}
-
-var connectedRelays = function () {
-  var counted = 0;
-
-  for (var i=0;i<PossibleRelayPins.length;i++) {
-    gpio.close(PossibleRelayPins[i]);
-    //console.log("Pins: " + PossibleRelayPins[i]);
-    gpio.open(PossibleRelayPins[i], gpio.OUTPUT, gpio.LOW);
-  }
-  for (i=0;i<PossibleRelayPins.length;i++) {
-    gpio.mode(PossibleRelayPins[i], gpio.INPUT);
-    //console.log("Pin %d = %d", PossibleRelayPins[i], gpio.read(PossibleRelayPins[i]));
-    if (gpio.read(PossibleRelayPins[i]) == 1) {
-      counted += 1;
-      RelayPins['PIN_RELAY_' + counted] = PossibleRelayPins[i];
-    }
-  }
-  // Reset for normal use
-  for (i=0;i<PossibleRelayPins.length;i++) {
-    gpio.close(PossibleRelayPins[i]);
-    //gpio.open(PossibleRelayPins[i], gpio.OUTPUT, RELAY_OFF);
-  }
-  return counted;
-};
-
-gpio.init({gpiomem: true, mapping: PIN_NUMBERING_MODE, exportDelay: 30});
-
-// Look for connected pins (populates RelayPins)
-var relayCount = connectedRelays();
-console.log("relayCount =  " + relayCount + ". " + JSON.stringify(RelayPins));
-
-console.log("\n\n\n");
-gpio.sleep(1);
-testConnected();
-
-//gpio.init({mapping: PIN_NUMBERING_MODE});
-/*
-gpio.close(11);
-console.log("closed 1");
-gpio.open(11, gpio.OUTPUT, RELAY_OFF);
-console.log("open 1");
-gpio.write(11, RELAY_ON);
-console.log("read = " + gpio.read(11));
-
-
-gpio.close(11);
-console.log("closed 2");
-*/
-
-
-/* ex:set ai shiftwidth=2 inputtab=spaces smarttab noautotab: */
-