Diff: main.cpp

Revision:

73:4e8ce0b18915

Parent:

72:884207c0aab0

Child:

74:822a92bc11d2

--- a/main.cpp	Wed Jan 04 20:14:12 2017 +0000
+++ b/main.cpp	Sat Jan 21 19:48:30 2017 +0000
@@ -163,6 +163,12 @@
 //        connection to the host (or so it appears to the device), but data 
 //        transmissions are failing.
 //
+//    medium blue flash = TV ON delay timer running.  This means that the
+//        power to the secondary PSU has just been turned on, and the TV ON
+//        timer is waiting for the configured delay time before pulsing the
+//        TV power button relay.  This is only shown if the TV ON feature is
+//        enabled.
+//
 //    long yellow/green = everything's working, but the plunger hasn't
 //        been calibrated.  Follow the calibration procedure described in
 //        the project documentation.  This flash mode won't appear if there's
@@ -297,56 +303,57 @@
 // they're so stingy, but it appears from empirical testing that we can 
 // create a static array up to about 9K before things get crashy.
 
+// Dynamic memory pool.  We'll reserve space for all dynamic 
+// allocations by creating a simple C array of bytes.  The size
+// of this array is the maximum number of bytes we can allocate
+// with malloc or operator 'new'.
+//
+// The maximum safe size for this array is, in essence, the
+// amount of physical KL25Z RAM left over after accounting for
+// static data throughout the rest of the program, the run-time
+// stack, and any other space reserved for compiler or MCU
+// overhead.  Unfortunately, it's not straightforward to
+// determine this analytically.  The big complication is that
+// the minimum stack size isn't easily predictable, as the stack
+// grows according to what the program does.  In addition, the
+// mbed platform tools don't give us detailed data on the
+// compiler/linker memory map.  All we get is a generic total
+// RAM requirement, which doesn't necessarily account for all
+// overhead (e.g., gaps inserted to get proper alignment for
+// particular memory blocks).  
+//
+// A very rough estimate: the total RAM size reported by the 
+// linker is about 3.5K (currently - that can obviously change 
+// as the project evolves) out of 16K total.  Assuming about a 
+// 3K stack, that leaves in the ballpark of 10K.  Empirically,
+// that seems pretty close.  In testing, we start to see some
+// instability at 10K, while 9K seems safe.  To be conservative,
+// we'll reduce this to 8K.
+//
+// Our measured total usage in the base configuration (22 GPIO
+// output ports, TSL1410R plunger sensor) is about 4000 bytes.
+// A pretty fully decked-out configuration (121 output ports,
+// with 8 TLC5940 chips and 3 74HC595 chips, plus the TSL1412R
+// sensor with the higher pixel count, and all expansion board
+// features enabled) comes to about 6700 bytes.  That leaves
+// us with about 1.5K free out of our 8K, so we still have a 
+// little more headroom for future expansion.
+//
+// For comparison, the standard mbed malloc() runs out of
+// memory at about 6K.  That's what led to this custom malloc:
+// we can just fit the base configuration into that 4K, but
+// it's not enough space for more complex setups.  There's
+// still a little room for squeezing out unnecessary space
+// from the mbed library code, but at this point I'd prefer
+// to treat that as a last resort, since it would mean having
+// to fork private copies of the libraries.
+static const size_t XMALLOC_POOL_SIZE = 8*1024;
+static char xmalloc_pool[XMALLOC_POOL_SIZE];
+static char *xmalloc_nxt = xmalloc_pool;
+static size_t xmalloc_rem = XMALLOC_POOL_SIZE;
+    
 void *xmalloc(size_t siz)
 {
-    // Dynamic memory pool.  We'll reserve space for all dynamic 
-    // allocations by creating a simple C array of bytes.  The size
-    // of this array is the maximum number of bytes we can allocate
-    // with malloc or operator 'new'.
-    //
-    // The maximum safe size for this array is, in essence, the
-    // amount of physical KL25Z RAM left over after accounting for
-    // static data throughout the rest of the program, the run-time
-    // stack, and any other space reserved for compiler or MCU
-    // overhead.  Unfortunately, it's not straightforward to
-    // determine this analytically.  The big complication is that
-    // the minimum stack size isn't easily predictable, as the stack
-    // grows according to what the program does.  In addition, the
-    // mbed platform tools don't give us detailed data on the
-    // compiler/linker memory map.  All we get is a generic total
-    // RAM requirement, which doesn't necessarily account for all
-    // overhead (e.g., gaps inserted to get proper alignment for
-    // particular memory blocks).  
-    //
-    // A very rough estimate: the total RAM size reported by the 
-    // linker is about 3.5K (currently - that can obviously change 
-    // as the project evolves) out of 16K total.  Assuming about a 
-    // 3K stack, that leaves in the ballpark of 10K.  Empirically,
-    // that seems pretty close.  In testing, we start to see some
-    // instability at 10K, while 9K seems safe.  To be conservative,
-    // we'll reduce this to 8K.
-    //
-    // Our measured total usage in the base configuration (22 GPIO
-    // output ports, TSL1410R plunger sensor) is about 4000 bytes.
-    // A pretty fully decked-out configuration (121 output ports,
-    // with 8 TLC5940 chips and 3 74HC595 chips, plus the TSL1412R
-    // sensor with the higher pixel count, and all expansion board
-    // features enabled) comes to about 6700 bytes.  That leaves
-    // us with about 1.5K free out of our 8K, so we still have a 
-    // little more headroom for future expansion.
-    //
-    // For comparison, the standard mbed malloc() runs out of
-    // memory at about 6K.  That's what led to this custom malloc:
-    // we can just fit the base configuration into that 4K, but
-    // it's not enough space for more complex setups.  There's
-    // still a little room for squeezing out unnecessary space
-    // from the mbed library code, but at this point I'd prefer
-    // to treat that as a last resort, since it would mean having
-    // to fork private copies of the libraries.
-    static char pool[8*1024];
-    static char *nxt = pool;
-    static size_t rem = sizeof(pool);
-    
     // align to a 4-byte increment
     siz = (siz + 3) & ~3;
     
@@ -360,7 +367,7 @@
     // context to handle failed allocations as fatal errors centrally.  We
     // can't recover from these automatically, so we have to resort to user
     // intervention, which we signal with the diagnostic LED flashes.
-    if (siz > rem)
+    if (siz > xmalloc_rem)
     {
         // halt with the diagnostic display (by looping forever)
         for (;;)
@@ -373,15 +380,17 @@
     }
 
     // get the next free location from the pool to return   
-    char *ret = nxt;
+    char *ret = xmalloc_nxt;
     
     // advance the pool pointer and decrement the remaining size counter
-    nxt += siz;
-    rem -= siz;
+    xmalloc_nxt += siz;
+    xmalloc_rem -= siz;
     
     // return the allocated block
     return ret;
-}
+};
+
+// our malloc() replacement
 
 // Overload operator new to call our custom malloc.  This ensures that
 // all 'new' allocations throughout the program (including library code)
@@ -542,15 +551,38 @@
 //
 DigitalOut *ledR, *ledG, *ledB;
 
+// Power on timer state for diagnostics.  We flash the blue LED when
+// nothing else is going on.  State 0-1 = off, 2-3 = on
+uint8_t powerTimerDiagState = 0;
+
 // Show the indicated pattern on the diagnostic LEDs.  0 is off, 1 is
 // on, and -1 is no change (leaves the current setting intact).
+static uint8_t diagLEDState = 0;
 void diagLED(int r, int g, int b)
 {
+    // remember the new state
+    diagLEDState = r | (g << 1) | (b << 2);
+    
+    // if turning everything off, use the power timer state instead, 
+    // applying it to the blue LED
+    if (diagLEDState == 0)
+        b = (powerTimerDiagState >= 2);
+        
+    // set the new state
     if (ledR != 0 && r != -1) ledR->write(!r);
     if (ledG != 0 && g != -1) ledG->write(!g);
     if (ledB != 0 && b != -1) ledB->write(!b);
 }
 
+// update the LEDs with the current state
+void diagLED(void)
+{
+    diagLED(
+        diagLEDState & 0x01,
+        (diagLEDState >> 1) & 0x01,
+        (diagLEDState >> 1) & 0x02);
+}
+
 // check an output port assignment to see if it conflicts with
 // an on-board LED segment
 struct LedSeg 
@@ -1053,13 +1085,56 @@
 static int numOutputs;
 static LwOut **lwPin;
 
-
-// Number of LedWiz emulation outputs.  This is the number of ports
-// accessible through the standard (non-extended) LedWiz protocol
-// messages.  The protocol has a fixed set of 32 outputs, but we
-// might have fewer actual outputs.  This is therefore set to the
-// lower of 32 or the actual number of outputs.
-static int numLwOutputs;
+// LedWiz output states.
+//
+// The LedWiz protocol has two separate control axes for each output.
+// One axis is its on/off state; the other is its "profile" state, which
+// is either a fixed brightness or a blinking pattern for the light.
+// The two axes are independent.
+//
+// Even though the original LedWiz protocol can only access 32 ports, we
+// maintain LedWiz state for every port, even if we have more than 32.  Our
+// extended protocol allows the client to select a bank of 32 outputs to
+// address via original protocol commands (SBA/PBA), which allows for one
+// Pinscape unit with more than 32 ports to be exposed on the client as
+// multiple virtual LedWiz units through a modified LEDWIZ.DLL interface
+// library.
+
+// Current LedWiz virtual unit: 0 = ports 1-32, 1 = ports 33-64, etc.
+// SBA and PBA messages address the block of ports set by this unit.
+uint8_t ledWizBank = 0;
+
+// on/off state for each LedWiz output
+static uint8_t *wizOn;
+
+// LedWiz "Profile State" (the LedWiz brightness level or blink mode)
+// for each LedWiz output.  If the output was last updated through an 
+// LedWiz protocol message, it will have one of these values:
+//
+//   0-48 = fixed brightness 0% to 100%
+//   49  = fixed brightness 100% (equivalent to 48)
+//   129 = ramp up / ramp down
+//   130 = flash on / off
+//   131 = on / ramp down
+//   132 = ramp up / on
+//
+// (Note that value 49 isn't documented in the LedWiz spec, but real
+// LedWiz units treat it as equivalent to 48, and some PC software uses
+// it, so we need to accept it for compatibility.)
+static uint8_t *wizVal;
+
+// LedWiz flash speed.  This is a value from 1 to 7 giving the pulse
+// rate for lights in blinking states.  Each bank of 32 lights has its
+// own pulse rate, so we need ceiling(number_of_physical_outputs/32)
+// entries here.  Note that we could allocate this dynamically, but
+// the maximum size is so small that it's more efficient to preallocate
+// it at the maximum size.
+static const int MAX_LW_BANKS = (MAX_OUT_PORTS+31)/32;
+static uint8_t wizSpeed[MAX_LW_BANKS];
+
+// Current LedWiz flash cycle counter.  This runs from 0 to 255
+// during each cycle. 
+static uint8_t wizFlashCounter[MAX_LW_BANKS];
 
 // Current absolute brightness levels for all outputs.  These are
 // DOF brightness level value, from 0 for fully off to 255 for fully
@@ -1219,19 +1294,23 @@
         }
     }
     
-    // the real LedWiz protocol can access at most 32 ports, or the
-    // actual number of outputs, whichever is lower
-    numLwOutputs = (numOutputs < 32 ? numOutputs : 32);
+    // allocate the pin array
+    lwPin = new LwOut*[numOutputs];
     
-    // allocate the pin array
-    lwPin = new LwOut*[numOutputs];    
+    // Allocate the current brightness array
+    outLevel = new uint8_t[numOutputs];
     
-    // Allocate the current brightness array.  For these, allocate at
-    // least 32, so that we have enough for all LedWiz messages, but
-    // allocate the full set of actual ports if we have more than the
-    // LedWiz complement.
-    int minOuts = numOutputs < 32 ? 32 : numOutputs;
-    outLevel = new uint8_t[minOuts];
+    // allocate the LedWiz output state arrays
+    wizOn = new uint8_t[numOutputs];
+    wizVal = new uint8_t[numOutputs];
+    
+    // initialize all LedWiz outputs to off and brightness 48
+    memset(wizOn, 0, numOutputs);
+    memset(wizVal, 48, numOutputs);
+    
+    // set all LedWiz virtual unit flash speeds to 2
+    for (i = 0 ; i < countof(wizSpeed) ; ++i)
+        wizSpeed[i] = 2;
     
     // create the pin interface object for each port
     for (i = 0 ; i < numOutputs ; ++i)
@@ -1260,7 +1339,7 @@
 // was used in the command.  On a legacy SBA or PBA, we switch to
 // LedWiz mode; on an extended output set message, we switch to
 // extended mode.  We remember the LedWiz and extended output state
-// for each LW ports (1-32) separately.  Any time the mode changes, 
+// for each LW port (1-32) separately.  Any time the mode changes, 
 // we set ports 1-32 back to the state for the new mode.
 //
 // The reasoning here is that any given client (on the PC) will use
@@ -1274,49 +1353,6 @@
 // program switching back and forth.
 static uint8_t ledWizMode = true;
 
-// LedWiz output states.
-//
-// The LedWiz protocol has two separate control axes for each output.
-// One axis is its on/off state; the other is its "profile" state, which
-// is either a fixed brightness or a blinking pattern for the light.
-// The two axes are independent.
-//
-// Note that the LedWiz protocol can only address 32 outputs, so the
-// wizOn and wizVal arrays have fixed sizes of 32 elements no matter
-// how many physical outputs we're using.
-
-// on/off state for each LedWiz output
-static uint8_t wizOn[32];
-
-// LedWiz "Profile State" (the LedWiz brightness level or blink mode)
-// for each LedWiz output.  If the output was last updated through an 
-// LedWiz protocol message, it will have one of these values:
-//
-//   0-48 = fixed brightness 0% to 100%
-//   49  = fixed brightness 100% (equivalent to 48)
-//   129 = ramp up / ramp down
-//   130 = flash on / off
-//   131 = on / ramp down
-//   132 = ramp up / on
-//
-// (Note that value 49 isn't documented in the LedWiz spec, but real
-// LedWiz units treat it as equivalent to 48, and some PC software uses
-// it, so we need to accept it for compatibility.)
-static uint8_t wizVal[32] = {
-    48, 48, 48, 48, 48, 48, 48, 48,
-    48, 48, 48, 48, 48, 48, 48, 48,
-    48, 48, 48, 48, 48, 48, 48, 48,
-    48, 48, 48, 48, 48, 48, 48, 48
-};
-
-// LedWiz flash speed.  This is a value from 1 to 7 giving the pulse
-// rate for lights in blinking states.
-static uint8_t wizSpeed = 2;
-
-// Current LedWiz flash cycle counter.  This runs from 0 to 255
-// during each cycle.
-static uint8_t wizFlashCounter = 0;
-
 // translate an LedWiz brightness level (0-49) to a DOF brightness
 // level (0-255)
 static const uint8_t lw_to_dof[] = {
@@ -1352,7 +1388,7 @@
         // the true 100% level.  (In the documentation, level 49 is
         // simply not a valid setting.)  Even so, we treat level 48 as
         // 100% on to match the documentation.  This won't be perfectly
-        // ocmpatible with the actual LedWiz, but it makes for such a
+        // compatible with the actual LedWiz, but it makes for such a
         // small difference in brightness (if the output device is an
         // LED, say) that no one should notice.  It seems better to
         // err in this direction, because while the difference in
@@ -1375,24 +1411,26 @@
     else if (val == 129)
     {
         // 129 = ramp up / ramp down
-        return wizFlashCounter < 128 
-            ? wizFlashCounter*2 + 1
-            : (255 - wizFlashCounter)*2;
+        const int c = wizFlashCounter[idx/32];
+        return c < 128 ? c*2 + 1 : (255 - c)*2;
     }
     else if (val == 130)
     {
         // 130 = flash on / off
-        return wizFlashCounter < 128 ? 255 : 0;
+        const int c = wizFlashCounter[idx/32];
+        return c < 128 ? 255 : 0;
     }
     else if (val == 131)
     {
         // 131 = on / ramp down
-        return wizFlashCounter < 128 ? 255 : (255 - wizFlashCounter)*2;
+        const int c = wizFlashCounter[idx/32];
+        return c < 128 ? 255 : (255 - c)*2;
     }
     else if (val == 132)
     {
         // 132 = ramp up / on
-        return wizFlashCounter < 128 ? wizFlashCounter*2 : 255;
+        const int c = wizFlashCounter[idx/32];
+        return c < 128 ? c*2 : 255;
     }
     else
     {
@@ -1418,13 +1456,16 @@
 #define WIZ_PULSE_TIME_BASE  (1.0f/127.0f)
 static void wizPulse()
 {
-    // increase the counter by the speed increment, and wrap at 256
-    wizFlashCounter += wizSpeed;
-    wizFlashCounter &= 0xff;
-    
-    // if we have any flashing lights, update them
-    int ena = false;
-    for (int i = 0 ; i < numLwOutputs ; ++i)
+    // update the flash counter in each bank
+    for (int bank = 0 ; bank < countof(wizFlashCounter) ; ++bank)
+    {
+        // increase the counter by the speed increment, and wrap at 256
+        wizFlashCounter[bank] = (wizFlashCounter[bank] + wizSpeed[bank]) & 0xff;
+    }
+
+    // look for outputs set to LedWiz flash modes 
+    int flashing = false;
+    for (int i = 0 ; i < numOutputs ; ++i)
     {
         if (wizOn[i])
         {
@@ -1432,7 +1473,7 @@
             if (s >= 129 && s <= 132)
             {
                 lwPin[i]->set(wizState(i));
-                ena = true;
+                flashing = true;
             }
         }
     }    
@@ -1443,7 +1484,7 @@
     // features when the host software doesn't care about the flashing 
     // modes.  For example, DOF never uses these modes, so there's no 
     // need for them when running Visual Pinball.
-    if (ena)
+    if (flashing)
         wizPulseTimer.attach(wizPulse, WIZ_PULSE_TIME_BASE);
 }
 
@@ -1453,7 +1494,7 @@
 {
     // update each output
     int pulse = false;
-    for (int i = 0 ; i < numLwOutputs ; ++i)
+    for (int i = 0 ; i < numOutputs ; ++i)
     {
         pulse |= (wizVal[i] >= 129 && wizVal[i] <= 132);
         lwPin[i]->set(wizState(i));
@@ -1473,15 +1514,41 @@
 // setting that affects all outputs, such as engaging or canceling Night Mode.
 static void updateAllOuts()
 {
-    // uddate each LedWiz output
-    for (int i = 0 ; i < numLwOutputs ; ++i)
+    // uddate each output
+    for (int i = 0 ; i < numOutputs ; ++i)
         lwPin[i]->set(wizState(i));
         
-    // update each extended output
-    for (int i = numLwOutputs ; i < numOutputs ; ++i)
-        lwPin[i]->set(outLevel[i]);
+    // flush 74HC595 changes, if necessary
+    if (hc595 != 0)
+        hc595->update();
+}
+
+//
+// Turn off all outputs and restore everything to the default LedWiz
+// state.  This sets outputs #1-32 to LedWiz profile value 48 (full
+// brightness) and switch state Off, sets all extended outputs (#33
+// and above) to zero brightness, and sets the LedWiz flash rate to 2.
+// This effectively restores the power-on conditions.
+//
+void allOutputsOff()
+{
+    // reset all LedWiz outputs to OFF/48
+    for (int i = 0 ; i < numOutputs ; ++i)
+    {
+        outLevel[i] = 0;
+        wizOn[i] = 0;
+        wizVal[i] = 48;
+        lwPin[i]->set(0);
+    }
+    
+    // restore default LedWiz flash rate
+    for (int i = 0 ; i < countof(wizSpeed) ; ++i)
+        wizSpeed[i] = 2;
         
-    // flush 74HC595 changes, if necessary
+    // set bank 0
+    ledWizBank = 0;
+    
+    // flush changes to hc595, if applicable
     if (hc595 != 0)
         hc595->update();
 }
@@ -1496,7 +1563,6 @@
 {
     ButtonState()
     {
-        di = NULL;
         physState = logState = prevLogState = 0;
         virtState = 0;
         dbState = 0;
@@ -1520,7 +1586,7 @@
     }
     
     // DigitalIn for the button, if connected to a physical input
-    TinyDigitalIn *di;
+    TinyDigitalIn di;
     
     // Time of last pulse state transition.
     //
@@ -1640,31 +1706,21 @@
 void scanButtons()
 {
     // scan all button input pins
-    ButtonState *bs = buttonState;
-    for (int i = 0 ; i < nButtons ; ++i, ++bs)
+    ButtonState *bs = buttonState, *last = bs + nButtons;
+    for ( ; bs < last ; ++bs)
     {
-        // if this logical button is connected to a physical input, check 
-        // the GPIO pin state
-        if (bs->di != NULL)
-        {
-            // Shift the new state into the debounce history.  Note that
-            // the physical pin inputs are active low (0V/GND = ON), so invert 
-            // the reading by XOR'ing the low bit with 1.  And of course we
-            // only want the low bit (since the history is effectively a bit
-            // vector), so mask the whole thing with 0x01 as well.
-            uint8_t db = bs->dbState;
-            db <<= 1;
-            db |= (bs->di->read() & 0x01) ^ 0x01;
-            bs->dbState = db;
-            
-            // if we have all 0's or 1's in the history for the required
-            // debounce period, the key state is stable - check for a change
-            // to the last stable state
-            const uint8_t stable = 0x1F;   // 00011111b -> 5 stable readings
-            db &= stable;
-            if (db == 0 || db == stable)
-                bs->physState = db & 1;
-        }
+        // Shift the new state into the debounce history
+        uint8_t db = (bs->dbState << 1) | bs->di.read();
+        bs->dbState = db;
+        
+        // If we have all 0's or 1's in the history for the required
+        // debounce period, the key state is stable, so apply the new
+        // physical state.  Note that the pins are active low, so the
+        // new button on/off state is the inverse of the GPIO state.
+        const uint8_t stable = 0x1F;   // 00011111b -> low 5 bits = last 5 readings
+        db &= stable;
+        if (db == 0 || db == stable)
+            bs->physState = !db;
     }
 }
 
@@ -1731,7 +1787,7 @@
             bs->cfgIndex = i;
 
             // set up the GPIO input pin for this button
-            bs->di = new TinyDigitalIn(pin);
+            bs->di.assignPin(pin);
             
             // if it's a pulse mode button, set the initial pulse state to Off
             if (cfg.button[i].flags & BtnFlagPulse)
@@ -2154,6 +2210,31 @@
     }
 }
 
+// Send a button status report
+void reportButtonStatus(USBJoystick &js)
+{
+    // start with all buttons off
+    uint8_t state[(MAX_BUTTONS+7)/8];
+    memset(state, 0, sizeof(state));
+
+    // pack the button states into bytes, one bit per button
+    ButtonState *bs = buttonState;
+    for (int i = 0 ; i < nButtons ; ++i, ++bs)
+    {
+        // get the physical state
+        int b = bs->physState;
+        
+        // pack it into the appropriate bit
+        int idx = bs->cfgIndex;
+        int si = idx / 8;
+        int shift = idx & 0x07;
+        state[si] |= b << shift;
+    }
+    
+    // send the report
+    js.reportButtonStatus(MAX_BUTTONS, state);
+}
+
 // ---------------------------------------------------------------------------
 //
 // Customization joystick subbclass
@@ -2506,13 +2587,14 @@
          vx_ = vy_ = 0;
 
          // get the time since the last get() sample
-         float dt = tGet_.read_us()/1.0e6f;
+         int dtus = tGet_.read_us();
          tGet_.reset();
          
          // done manipulating the shared data
          __enable_irq();
          
          // adjust the readings for the integration time
+         float dt = dtus/1000000.0f;
          vx /= dt;
          vy /= dt;
          
@@ -2773,40 +2855,6 @@
 
 // ---------------------------------------------------------------------------
 //
-// Turn off all outputs and restore everything to the default LedWiz
-// state.  This sets outputs #1-32 to LedWiz profile value 48 (full
-// brightness) and switch state Off, sets all extended outputs (#33
-// and above) to zero brightness, and sets the LedWiz flash rate to 2.
-// This effectively restores the power-on conditions.
-//
-void allOutputsOff()
-{
-    // reset all LedWiz outputs to OFF/48
-    for (int i = 0 ; i < numLwOutputs ; ++i)
-    {
-        outLevel[i] = 0;
-        wizOn[i] = 0;
-        wizVal[i] = 48;
-        lwPin[i]->set(0);
-    }
-    
-    // reset all extended outputs (ports >32) to full off (brightness 0)
-    for (int i = numLwOutputs ; i < numOutputs ; ++i)
-    {
-        outLevel[i] = 0;
-        lwPin[i]->set(0);
-    }
-    
-    // restore default LedWiz flash rate
-    wizSpeed = 2;
-    
-    // flush changes to hc595, if applicable
-    if (hc595 != 0)
-        hc595->update();
-}
-
-// ---------------------------------------------------------------------------
-//
 // TV ON timer.  If this feature is enabled, we toggle a TV power switch
 // relay (connected to a GPIO pin) to turn on the cab's TV monitors shortly
 // after the system is powered.  This is useful for TVs that don't remember
@@ -2882,14 +2930,38 @@
 //   3 -> SET pulsed low, ready to check status
 //   4 -> TV timer countdown in progress
 //   5 -> TV relay on
-int psu2_state = 1;
+uint8_t psu2_state = 1;
+
+// TV relay state.  The TV relay can be controlled by the power-on
+// timer and directly from the PC (via USB commands), so keep a
+// separate state for each:
+//
+//   0x01 -> turned on by power-on timer
+//   0x02 -> turned on by USB command
+uint8_t tv_relay_state = 0x00;
+const uint8_t TV_RELAY_POWERON = 0x01;
+const uint8_t TV_RELAY_USB     = 0x02;
+
+// TV ON switch relay control
+DigitalOut *tv_relay;
 
 // PSU2 power sensing circuit connections
 DigitalIn *psu2_status_sense;
 DigitalOut *psu2_status_set;
 
-// TV ON switch relay control
-DigitalOut *tv_relay;
+// Apply the current TV relay state
+void tvRelayUpdate(uint8_t bit, bool state)
+{
+    // update the state
+    if (state)
+        tv_relay_state |= bit;
+    else
+        tv_relay_state &= ~bit;
+    
+    // set the relay GPIO to the new state
+    if (tv_relay != 0)
+        tv_relay->write(tv_relay_state != 0);
+}
 
 // Timer interrupt
 Ticker tv_ticker;
@@ -2937,6 +3009,10 @@
             tv_timer.reset();
             tv_timer.start();
             psu2_state = 4;
+            
+            // start the power timer diagnostic flashes
+            powerTimerDiagState = 2;
+            diagLED();
         }
         else
         {
@@ -2954,16 +3030,24 @@
         if (tv_timer.read() >= tv_delay_time)
         {
             // turn on the relay for one timer interval
-            tv_relay->write(1);
+            tvRelayUpdate(TV_RELAY_POWERON, true);
             psu2_state = 5;
         }
+        
+        // flash the power time diagnostic every two interrupts
+        powerTimerDiagState = (powerTimerDiagState + 1) & 0x03;
+        diagLED();
         break;
         
     case 5:
         // TV timer relay on.  We pulse this for one interval, so
         // it's now time to turn it off and return to the default state.
-        tv_relay->write(0);
+        tvRelayUpdate(TV_RELAY_POWERON, false);
         psu2_state = 1;
+        
+        // done with the diagnostic flashes
+        powerTimerDiagState = 0;
+        diagLED();
         break;
     }
 }
@@ -2984,13 +3068,56 @@
         psu2_status_sense = new DigitalIn(wirePinName(cfg.TVON.statusPin));
         psu2_status_set = new DigitalOut(wirePinName(cfg.TVON.latchPin));
         tv_relay = new DigitalOut(wirePinName(cfg.TVON.relayPin));
-        tv_delay_time = cfg.TVON.delayTime/100.0;
+        tv_delay_time = cfg.TVON.delayTime/100.0f;
     
         // Set up our time routine to run every 1/4 second.  
         tv_ticker.attach(&TVTimerInt, 0.25);
     }
 }
 
+// TV relay manual control timer.  This lets us pulse the TV relay
+// under manual control, separately from the TV ON timer.
+Ticker tv_manualTicker;
+void TVManualInt()
+{
+    tv_manualTicker.detach();
+    tvRelayUpdate(TV_RELAY_USB, false);
+}
+
+// Operate the TV ON relay.  This allows manual control of the relay
+// from the PC.  See protocol message 65 submessage 11.
+//
+// Mode:
+//    0 = turn relay off
+//    1 = turn relay on
+//    2 = pulse relay 
+void TVRelay(int mode)
+{
+    // if there's no TV relay control pin, ignore this
+    if (tv_relay == 0)
+        return;
+    
+    switch (mode)
+    {
+    case 0:
+        // relay off
+        tvRelayUpdate(TV_RELAY_USB, false);
+        break;
+        
+    case 1:
+        // relay on
+        tvRelayUpdate(TV_RELAY_USB, true);
+        break;
+        
+    case 2:
+        // Pulse the relay.  Turn it on, then set our timer for 250ms.
+        tvRelayUpdate(TV_RELAY_USB, true);
+        tv_manualTicker.attach(&TVManualInt, 0.25);
+        break;
+    }
+}
+
+
 // ---------------------------------------------------------------------------
 //
 // In-memory configuration data structure.  This is the live version in RAM
@@ -3652,11 +3779,122 @@
 
 private:
 
-#if 1
+// Plunger data filtering mode:  optionally apply filtering to the raw 
+// plunger sensor readings to try to reduce noise in the signal.  This
+// is designed for the TSL1410/12 optical sensors, where essentially all
+// of the noise in the signal comes from lack of sharpness in the shadow
+// edge.  When the shadow is blurry, the edge detector has to pick a pixel,
+// even though the edge is actually a gradient spanning several pixels.
+// The edge detection algorithm decides on the exact pixel, but whatever
+// the algorithm, the choice is going to be somewhat arbitrary given that
+// there's really no one pixel that's "the edge" when the edge actually
+// covers multiple pixels.  This can make the choice of pixel sensitive to
+// small changes in exposure and pixel respose from frame to frame, which
+// means that the reported edge position can move by a pixel or two from
+// one frame to the next even when the physical plunger is perfectly still.
+// That's the noise we're talking about.
+//
+// We previously applied a mild hysteresis filter to the signal to try to
+// eliminate this noise.  The filter tracked the average over the last
+// several samples, and rejected readings that wandered within a few
+// pixels of the average.  If a certain number of readings moved away from
+// the average in the same direction, even by small amounts, the filter
+// accepted the changes, on the assumption that they represented actual
+// slow movement of the plunger.  This filter was applied after the firing
+// detection.
+//
+// I also tried a simpler filter that rejected changes that were too fast
+// to be physically possible, as well as changes that were very close to
+// the last reported position (i.e., simple hysteresis).  The "too fast"
+// filter was there to reject spurious readings where the edge detector
+// mistook a bad pixel value as an edge.  
+//
+// The new "mode 2" edge detector (see ccdSensor.h) seems to do a better
+// job of rejecting pixel-level noise by itself than the older "mode 0"
+// algorithm did, so I removed the filtering entirely.  Any filtering has
+// some downsides, so it's better to reduce noise in the underlying signal
+// as much as possible first.  It seems possible to get a very stable signal
+// now with a combination of the mode 2 edge detector and optimizing the
+// physical sensor arrangement, especially optimizing the light source to
+// cast as sharp as shadow as possible and adjusting the brightness to
+// maximize bright/dark contrast in the image.
+//
+//   0 = No filtering (current default)
+//   1 = Filter the data after firing detection using moving average
+//       hysteresis filter (old version, used in most 2016 releases)
+//   2 = Filter the data before firing detection using simple hysteresis
+//       plus spurious "too fast" motion rejection
+//
+#define PLUNGER_FILTERING_MODE  0
+
+#if PLUNGER_FILTERING_MODE == 0
     // Disable all filtering
     void applyPreFilter(PlungerReading &r) { }
     int applyPostFilter() { return z; }
-#elif 1
+#elif PLUNGER_FILTERING_MODE == 1
+    // Apply pre-processing filter.  This filter is applied to the raw
+    // value coming off the sensor, before calibration or fire-event
+    // processing.
+    void applyPreFilter(PlungerReading &r)
+    {
+    }
+    
+    // Figure the next post-processing filtered value.  This applies a
+    // hysteresis filter to the last raw z value and returns the 
+    // filtered result.
+    int applyPostFilter()
+    { 
+        if (firing <= 1)
+        {
+            // Filter limit - 5 samples.  Once we've been moving
+            // in the same direction for this many samples, we'll
+            // clear the history and start over.
+            const int filterMask = 0x1f;
+            
+            // figure the last average
+            int lastAvg = int(filterSum / filterN);
+            
+            // figure the direction of this sample relative to the average,
+            // and shift it in to our bit mask of recent direction data
+            if (z != lastAvg)
+            {
+                // shift the new direction bit into the vector
+                filterDir <<= 1;
+                if (z > lastAvg) filterDir |= 1;
+            }
+            
+            // keep only the last N readings, up to the filter limit
+            filterDir &= filterMask;
+            
+            // if we've been moving consistently in one direction (all 1's
+            // or all 0's in the direction history vector), reset the average
+            if (filterDir == 0x00 || filterDir == filterMask) 
+            {
+                // motion away from the average - reset the average
+                filterDir = 0x5555;
+                filterN = 1;
+                filterSum = (lastAvg + z)/2;
+                return int16_t(filterSum);
+            }
+            else
+            {
+                // we're directionless - return the new average, with the 
+                // new sample included
+                filterSum += z;
+                ++filterN;
+                return int16_t(filterSum / filterN);
+            }
+        }
+        else
+        {
+            // firing mode - skip the filter
+            filterN = 1;
+            filterSum = z;
+            filterDir = 0x5555;
+            return z;
+        }
+    }
+#elif PLUNGER_FILTERING_MODE == 2
     // Apply pre-processing filter.  This filter is applied to the raw
     // value coming off the sensor, before calibration or fire-event
     // processing.
@@ -3725,69 +3963,6 @@
     {
         return z;
     }
-#else
-    // Apply pre-processing filter.  This filter is applied to the raw
-    // value coming off the sensor, before calibration or fire-event
-    // processing.
-    void applyPreFilter(PlungerReading &r)
-    {
-    }
-    
-    // Figure the next post-processing filtered value.  This applies a
-    // hysteresis filter to the last raw z value and returns the 
-    // filtered result.
-    int applyPostFilter()
-    { 
-        if (firing <= 1)
-        {
-            // Filter limit - 5 samples.  Once we've been moving
-            // in the same direction for this many samples, we'll
-            // clear the history and start over.
-            const int filterMask = 0x1f;
-            
-            // figure the last average
-            int lastAvg = int(filterSum / filterN);
-            
-            // figure the direction of this sample relative to the average,
-            // and shift it in to our bit mask of recent direction data
-            if (z != lastAvg)
-            {
-                // shift the new direction bit into the vector
-                filterDir <<= 1;
-                if (z > lastAvg) filterDir |= 1;
-            }
-            
-            // keep only the last N readings, up to the filter limit
-            filterDir &= filterMask;
-            
-            // if we've been moving consistently in one direction (all 1's
-            // or all 0's in the direction history vector), reset the average
-            if (filterDir == 0x00 || filterDir == filterMask) 
-            {
-                // motion away from the average - reset the average
-                filterDir = 0x5555;
-                filterN = 1;
-                filterSum = (lastAvg + z)/2;
-                return int16_t(filterSum);
-            }
-            else
-            {
-                // we're directionless - return the new average, with the 
-                // new sample included
-                filterSum += z;
-                ++filterN;
-                return int16_t(filterSum / filterN);
-            }
-        }
-        else
-        {
-            // firing mode - skip the filter
-            filterN = 1;
-            filterSum = z;
-            filterDir = 0x5555;
-            return z;
-        }
-    }
 #endif
     
     void initFilter()
@@ -4199,7 +4374,7 @@
 #define v_byte(var, ofs)    data[ofs] = cfg.var
 #define v_ui16(var, ofs)    ui16Wire(data+(ofs), cfg.var)
 #define v_pin(var, ofs)     pinNameWire(data+(ofs), cfg.var)
-#define v_byte_ro(val, ofs) data[ofs] = val
+#define v_byte_ro(val, ofs) data[ofs] = (val)
 #define v_func  configVarGet
 #include "cfgVarMsgMap.h"
 
@@ -4241,24 +4416,23 @@
         ledWizMode = true;
 
         // update all on/off states
-        for (int i = 0, bit = 1, ri = 1 ; i < numLwOutputs ; ++i, bit <<= 1)
+        for (int i = 0, bit = 1, imsg = 1, iwiz = ledWizBank*32 ; 
+             i < 32 && iwiz < numOutputs ;
+             ++i, ++iwiz, bit <<= 1)
         {
             // figure the on/off state bit for this output
             if (bit == 0x100) {
                 bit = 1;
-                ++ri;
+                ++imsg;
             }
             
             // set the on/off state
-            wizOn[i] = ((data[ri] & bit) != 0);
+            wizOn[iwiz] = ((data[imsg] & bit) != 0);
         }
         
         // set the flash speed - enforce the value range 1-7
-        wizSpeed = data[5];
-        if (wizSpeed < 1)
-            wizSpeed = 1;
-        else if (wizSpeed > 7)
-            wizSpeed = 7;
+        if (ledWizBank < countof(wizSpeed))
+            wizSpeed[ledWizBank] = (data[5] < 1 ? 1 : data[5] > 7 ? 7 : data[5]);
 
         // update the physical outputs
         updateWizOuts();
@@ -4337,7 +4511,7 @@
                 numOutputs, 
                 cfg.psUnitNo - 1,   // report 0-15 range for unit number (we store 1-16 internally)
                 cfg.plunger.cal.zero, cfg.plunger.cal.max, cfg.plunger.cal.tRelease,
-                nvm.valid());
+                nvm.valid(), xmalloc_rem);
             break;
             
         case 5:
@@ -4391,6 +4565,26 @@
             // 10 = Build ID query.
             js.reportBuildInfo(getBuildID());
             break;
+            
+        case 11:
+            // 11 = TV ON relay control.
+            //      data[2] = operation:
+            //         0 = turn relay off
+            //         1 = turn relay on
+            //         2 = pulse relay (as though the power-on timer fired)
+            TVRelay(data[2]);
+            break;
+            
+        case 12:
+            // 12 = Select virtual LedWiz unit.  This selects a bank of 32
+            // outputs for subsequent SBA and PBA messages.
+            ledWizBank = data[2];
+            break;
+            
+        case 13:
+            // 13 = Send button status report
+            reportButtonStatus(js);
+            break;
         }
     }
     else if (data[0] == 66)
@@ -4471,15 +4665,17 @@
         // flag that we received an LedWiz message
         ledWizMode = true;
 
-        // Update all output profile settings
-        for (int i = 0 ; i < 8 ; ++i)
-            wizVal[pbaIdx + i] = data[i];
+        // Update all output profile settings for the current bank
+        for (int i = 0, iwiz = ledWizBank*32 + pbaIdx ; 
+             i < 8 && iwiz < numOutputs ; 
+             ++i, ++iwiz)
+            wizVal[iwiz] = data[i];
 
         // Update the physical LED state if this is the last bank.
         // Note that hosts always send a full set of four PBA
         // messages, so there's no need to do a physical update
         // until we've received the last bank's PBA message.
-        if (pbaIdx == 24)
+        if (pbaIdx >= 24)
         {
             updateWizOuts();
             if (hc595 != 0)
@@ -4817,7 +5013,8 @@
         // figure the current status flags for joystick reports
         uint16_t statusFlags =
             (cfg.plunger.enabled ? 0x01 : 0x00)
-            | (nightMode ? 0x02 : 0x00);
+            | (nightMode ? 0x02 : 0x00)
+            | ((psu2_state & 0x07) << 2);
 
         // If it's been long enough since our last USB status report, send
         // the new report.  VP only polls for input in 10ms intervals, so
@@ -5040,6 +5237,12 @@
                     jsOKTimer.stop();
                 }
             }
+            else if (psu2_state >= 4)
+            {
+                // We're in the TV timer countdown.  Skip the normal heartbeat
+                // flashes and show the TV timer flashes instead.
+                diagLED(0, 0, 0);
+            }
             else if (cfg.plunger.enabled && !cfg.plunger.cal.calibrated)
             {
                 // connected, plunger calibration needed - flash yellow/green