Diff: main.cpp

Revision:

53:9b2611964afc

Parent:

52:8298b2a73eb2

Child:

54:fd77a6b2f76c

--- a/main.cpp	Sat Mar 05 00:16:52 2016 +0000
+++ b/main.cpp	Fri Apr 22 17:58:35 2016 +0000
@@ -82,57 +82,53 @@
 //    to the PC as a joystick button or as a keyboard key (you can select which key
 //    is used for each button).
 //
-//  - LedWiz emulation.  The KL25Z can appear to the PC as an LedWiz device, and will
-//    accept and process LedWiz commands from the host.  The software can turn digital
-//    output ports on and off, and can set varying PWM intensitiy levels on a subset
-//    of ports.  The KL25Z hardware is limited to 10 PWM ports.  Ports beyond the
-//    10 PWM ports are simple digital on/off ports.  Intensity level settings on 
-//    digital ports is ignored, so such ports can only be used for devices such as 
-//    contactors and solenoids that don't need differeing intensities.
+//  - LedWiz emulation.  The KL25Z can pretend to be an LedWiz device.  This lets
+//    you connect feedback devices (lights, solenoids, motors) to GPIO ports on the 
+//    KL25Z, and lets PC software (such as Visual Pinball) control them during game 
+//    play to create a more immersive playing experience.  The Pinscape software
+//    presents itself to the host as an LedWiz device and accepts the full LedWiz
+//    command set, so software on the PC designed for real LedWiz'es can control
+//    attached devices without any modifications.
 //
-//    Note that the KL25Z can only supply or sink 4mA on its output ports, so external 
-//    amplifier hardware is required to use the LedWiz emulation.  Many different 
-//    hardware designs are possible, but there's a simple reference design in the 
-//    documentation that uses a Darlington array IC to increase the output from 
-//    each port to 500mA (the same level as the LedWiz), plus an extended design 
-//    that adds an optocoupler and MOSFET to provide very high power handling, up 
-//    to about 45A or 150W, with voltages up to 100V.  That will handle just about 
-//    any DC device directly (wtihout relays or other amplifiers), and switches fast 
-//    enough to support PWM devices.  For example, you can use it to drive a motor at
-//    different speeds via the PWM intensity.
-//
-//    The Controller device can report any desired LedWiz unit number to the host, 
-//    which makes it possible for one or more Pinscape Controller units to coexist
-//    with one more more real LedWiz units in the same machine.  The LedWiz design 
-//    allows for up to 16 units to be installed in one machine.  Each device needs
-//    to have a distinct LedWiz Unit Number, which allows software on the PC to
-//    address each device independently.
-//
-//    The LedWiz emulation features are of course optional.  There's no need to 
-//    build any of the external port hardware (or attach anything to the output 
-//    ports at all) if the LedWiz features aren't needed.
+//    Even though the software provides a very thorough LedWiz emulation, the KL25Z
+//    GPIO hardware design imposes some serious limitations.  The big one is that
+//    the KL25Z only has 10 PWM channels, meaning that only 10 ports can have
+//    varying-intensity outputs (e.g., for controlling the brightness level of an
+//    LED or the speed or a motor).  You can control more than 10 output ports, but
+//    only 10 can have PWM control; the rest are simple "digital" ports that can only
+//    be switched fully on or fully off.  The second limitation is that the KL25Z
+//    just doesn't have that many GPIO ports overall.  There are enough to populate
+//    all 32 button inputs OR all 32 LedWiz outputs, but not both.  The default is
+//    to assign 24 buttons and 22 LedWiz ports; you can change this balance to trade
+//    off more outputs for fewer inputs, or vice versa.  The third limitation is that
+//    the KL25Z GPIO pins have *very* tiny amperage limits - just 4mA, which isn't
+//    even enough to control a small LED.  So in order to connect any kind of feedback
+//    device to an output, you *must* build some external circuitry to boost the
+//    current handing.  The Build Guide has a reference circuit design for this
+//    purpose that's simple and inexpensive to build.
 //
 //  - Enhanced LedWiz emulation with TLC5940 PWM controller chips.  You can attach
 //    external PWM controller chips for controlling device outputs, instead of using
-//    the limited LedWiz emulation through the on-board GPIO ports as described above. 
-//    The software can control a set of daisy-chained TLC5940 chips, which provide
-//    16 PWM outputs per chip.  Two of these chips give you the full complement
-//    of 32 output ports of an actual LedWiz, and four give you 64 ports, which
-//    should be plenty for nearly any virtual pinball project.  A private, extended
-//    version of the LedWiz protocol lets the host control the extra outputs, up to
-//    128 outputs per KL25Z (8 TLC5940s).  To take advantage of the extra outputs
-//    on the PC side, you need software that knows about the protocol extensions,
-//    which means you need the latest version of DirectOutput Framework (DOF).  VP
-//    uses DOF for its output, so VP will be able to use the added ports without any
-//    extra work on your part.  Older software (e.g., Future Pinball) that doesn't
-//    use DOF will still be able to use the LedWiz-compatible protocol, so it'll be
-//    able to control your first 32 ports (numbered 1-32 in the LedWiz scheme), but
-//    older software won't be able to address higher-numbered ports.  That shouldn't
-//    be a problem because older software wouldn't know what to do with the extra
-//    devices anyway - FP, for example, is limited to a pre-defined set of outputs.
-//    As long as you put the most common devices on the first 32 outputs, and use
-//    higher numbered ports for the less common devices that older software can't
-//    use anyway, you'll get maximum functionality out of software new and old.
+//    the on-board GPIO ports as described above.  The software can control a set of 
+//    daisy-chained TLC5940 chips.  Each chip provides 16 PWM outputs, so you just
+//    need two of them to get the full complement of 32 output ports of a real LedWiz.
+//    You can hook up even more, though.  Four chips gives you 64 ports, which should
+//    be plenty for nearly any virtual pinball project.  To accommodate the larger
+//    supply of ports possible with the PWM chips, the controller software provides
+//    a custom, extended version of the LedWiz protocol that can handle up to 128
+//    ports.  PC software designed only for the real LedWiz obviously won't know
+//    about the extended protocol and won't be able to take advantage of its extra
+//    capabilities, but the latest version of DOF (DirectOutput Framework) *does* 
+//    know the new language and can take full advantage.  Older software will still
+//    work, though - the new extensions are all backward compatible, so old software
+//    that only knows about the original LedWiz protocol will still work, with the
+//    obvious limitation that it can only access the first 32 ports.
+//
+//    The Pinscape Expansion Board project (which appeared in early 2016) provides
+//    a reference hardware design, with EAGLE circuit board layouts, that takes full
+//    advantage of the TLC5940 capability.  It lets you create a customized set of
+//    outputs with full PWM control and power handling for high-current devices
+//    built in to the boards.  
 //
 //  - Night Mode control for output devices.  You can connect a switch or button
 //    to the controller to activate "Night Mode", which disables feedback devices
@@ -213,6 +209,71 @@
 #define DECL_EXTERNS
 #include "config.h"
 
+
+// --------------------------------------------------------------------------
+// 
+// OpenSDA module identifier.  This is for the benefit of the Windows
+// configuration tool.  When the config tool installs a .bin file onto
+// the KL25Z, it will first find the sentinel string within the .bin file,
+// and patch the "\0" bytes that follow the sentinel string with the 
+// OpenSDA module ID data.  This allows us to report the OpenSDA 
+// identifiers back to the host system via USB, which in turn allows the 
+// config tool to figure out which OpenSDA MSD (mass storage device - a 
+// virtual disk drive) correlates to which Pinscape controller USB 
+// interface.  
+// 
+// This is only important if multiple Pinscape devices are attached to 
+// the same host.  There doesn't seem to be any other way to figure out 
+// which OpenSDA MSD corresponds to which KL25Z USB interface; the OpenSDA 
+// MSD doesn't report the KL25Z CPU ID anywhere, and the KL25Z doesn't
+// have any way to learn about the OpenSDA module it's connected to.  The
+// only way to pass this information to the KL25Z side that I can come up 
+// with is to have the Windows host embed it in the .bin file before 
+// downloading it to the OpenSDA MSD.
+//
+// We initialize the const data buffer (the part after the sentinel string)
+// with all "\0" bytes, so that's what will be in the executable image that
+// comes out of the mbed compiler.  If you manually install the resulting
+// .bin file onto the KL25Z (via the Windows desktop, say), the "\0" bytes
+// will stay this way and read as all 0's at run-time.  Since a real TUID
+// would never be all 0's, that tells us that we were never patched and
+// thus don't have any information on the OpenSDA module.
+//
+const char *getOpenSDAID()
+{
+    #define OPENSDA_PREFIX "///Pinscape.OpenSDA.TUID///"
+    static const char OpenSDA[] = OPENSDA_PREFIX "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0///";
+    const size_t OpenSDA_prefix_length = sizeof(OPENSDA_PREFIX) - 1;
+    
+    return OpenSDA + OpenSDA_prefix_length;
+}
+
+// --------------------------------------------------------------------------
+//
+// Build ID.  We use the date and time of compiling the program as a build
+// identifier.  It would be a little nicer to use a simple serial number
+// instead, but the mbed platform doesn't have a way to automate that.  The
+// timestamp is a pretty good proxy for a serial number in that it will
+// naturally increase on each new build, which is the primary property we
+// want from this.
+//
+// As with the embedded OpenSDA ID, we store the build timestamp with a
+// sentinel string prefix, to allow automated tools to find the static data
+// in the .bin file by searching for the sentinel string.  In contrast to 
+// the OpenSDA ID, the value we store here is for tools to extract rather 
+// than store, since we automatically populate it via the preprocessor 
+// macros.
+//
+const char *getBuildID()
+{
+    #define BUILDID_PREFIX "///Pinscape.Build.ID///"
+    static const char BuildID[] = BUILDID_PREFIX __DATE__ " " __TIME__ "///";
+    const size_t BuildID_prefix_length = sizeof(BUILDID_PREFIX) - 1;
+    
+    return BuildID + BuildID_prefix_length;
+}
+
+
 // --------------------------------------------------------------------------
 //
 // Custom memory allocator.  We use our own version of malloc() to provide
@@ -276,6 +337,14 @@
     bool running;
 };
 
+
+// --------------------------------------------------------------------------
+//
+// Reboot timer.  When we have a deferred reboot operation pending, we
+// set the target time and start the timer.
+Timer2 rebootTimer;
+long rebootTime_us;
+
 // --------------------------------------------------------------------------
 // 
 // USB product version number
@@ -332,29 +401,36 @@
     return (int32_t)wireUI32(b);
 }
 
-static const PinName pinNameMap[] =  {
-    NC,    PTA1,  PTA2,  PTA4,  PTA5,  PTA12, PTA13, PTA16, PTA17, PTB0,    // 0-9
-    PTB1,  PTB2,  PTB3,  PTB8,  PTB9,  PTB10, PTB11, PTB18, PTB19, PTC0,    // 10-19
-    PTC1,  PTC2,  PTC3,  PTC4,  PTC5,  PTC6,  PTC7,  PTC8,  PTC9,  PTC10,   // 20-29
-    PTC11, PTC12, PTC13, PTC16, PTC17, PTD0,  PTD1,  PTD2,  PTD3,  PTD4,    // 30-39
-    PTD5,  PTD6,  PTD7,  PTE0,  PTE1,  PTE2,  PTE3,  PTE4,  PTE5,  PTE20,   // 40-49
-    PTE21, PTE22, PTE23, PTE29, PTE30, PTE31                                // 50-55
-};
-inline PinName wirePinName(int c)
+// Convert "wire" (USB) pin codes to/from PinName values.
+// 
+// The internal mbed PinName format is 
+//
+//   ((port) << PORT_SHIFT) | (pin << 2)    // MBED FORMAT
+//
+// where 'port' is 0-4 for Port A to Port E, and 'pin' is
+// 0 to 31.  E.g., E31 is (4 << PORT_SHIFT) | (31<<2).
+//
+// We remap this to our more compact wire format where each
+// pin name fits in 8 bits:
+//
+//   ((port) << 5) | pin)                   // WIRE FORMAT
+//
+// E.g., E31 is (4 << 5) | 31.
+//
+// Wire code FF corresponds to PinName NC (not connected).
+//
+inline PinName wirePinName(uint8_t c)
 {
-    return (c < countof(pinNameMap) ? pinNameMap[c] : NC);
+    if (c == 0xFF)
+        return NC;                                  // 0xFF -> NC
+    else 
+        return PinName(
+            (int(c & 0xE0) << (PORT_SHIFT - 5))      // top three bits are the port
+            | (int(c & 0x1F) << 2));                // bottom five bits are pin
 }
 inline void pinNameWire(uint8_t *b, PinName n)
 {
-    b[0] = 0; // presume invalid -> NC
-    for (int i = 0 ; i < countof(pinNameMap) ; ++i)
-    {
-        if (pinNameMap[i] == n)
-        {
-            b[0] = i;
-            return;
-        }
-    }
+    *b = PINNAME_TO_WIRE(n);
 }
 
 
@@ -420,10 +496,6 @@
     for (int i = 0 ; i < MAX_OUT_PORTS && cfg.outPort[i].typ != PortTypeDisabled ; ++i)
         l.check(cfg.outPort[i]);
     
-    // check the special ports
-    for (int i = 0 ; i < countof(cfg.specialPort) ; ++i)
-        l.check(cfg.specialPort[i]);
-    
     // We now know which segments are taken for LedWiz use and which
     // are free.  Create diagnostic ports for the ones not claimed for
     // LedWiz use.
@@ -495,9 +567,34 @@
     virtual void set(uint8_t val) { out->set(255 - val); }
     
 private:
+    // underlying physical output
     LwOut *out;
 };
 
+// Global ZB Launch Ball state
+bool zbLaunchOn = false;
+
+// ZB Launch Ball output.  This is layered on a port (physical or virtual)
+// to track the ZB Launch Ball signal.
+class LwZbLaunchOut: public LwOut
+{
+public:
+    LwZbLaunchOut(LwOut *o) : out(o) { }
+    virtual void set(uint8_t val)
+    {
+        // update the global ZB Launch Ball state
+        zbLaunchOn = (val != 0);
+        
+        // pass it along to the underlying port, in case it's a physical output
+        out->set(val);
+    }
+        
+private:
+    // underlying physical or virtual output
+    LwOut *out;
+};
+
+
 // Gamma correction table for 8-bit input values
 static const uint8_t gamma[] = {
       0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0, 
@@ -531,6 +628,9 @@
     LwOut *out;
 };
 
+// global night mode flag
+static bool nightMode = false;
+
 // Noisy output.  This is a filter object that we layer on top of
 // a physical pin output.  This filter disables the port when night
 // mode is engaged.
@@ -540,15 +640,28 @@
     LwNoisyOut(LwOut *o) : out(o) { }
     virtual void set(uint8_t val) { out->set(nightMode ? 0 : val); }
     
-    static bool nightMode;
+private:
+    LwOut *out;
+};
+
+// Night Mode indicator output.  This is a filter object that we
+// layer on top of a physical pin output.  This filter ignores the
+// host value and simply shows the night mode status.
+class LwNightModeIndicatorOut: public LwOut
+{
+public:
+    LwNightModeIndicatorOut(LwOut *o) : out(o) { }
+    virtual void set(uint8_t) 
+    {
+        // ignore the host value and simply show the current 
+        // night mode setting
+        out->set(nightMode ? 255 : 0);
+    }
 
 private:
     LwOut *out;
 };
 
-// global night mode flag
-bool LwNoisyOut::nightMode = false;
-
 
 //
 // The TLC5940 interface object.  We'll set this up with the port 
@@ -559,8 +672,13 @@
 {
     if (cfg.tlc5940.nchips != 0)
     {
-        tlc5940 = new TLC5940(cfg.tlc5940.sclk, cfg.tlc5940.sin, cfg.tlc5940.gsclk,
-            cfg.tlc5940.blank, cfg.tlc5940.xlat, cfg.tlc5940.nchips);
+        tlc5940 = new TLC5940(
+            wirePinName(cfg.tlc5940.sclk), 
+            wirePinName(cfg.tlc5940.sin),
+            wirePinName(cfg.tlc5940.gsclk),
+            wirePinName(cfg.tlc5940.blank), 
+            wirePinName(cfg.tlc5940.xlat), 
+            cfg.tlc5940.nchips);
     }
 }
 
@@ -656,7 +774,12 @@
 {
     if (cfg.hc595.nchips != 0)
     {
-        hc595 = new HC595(cfg.hc595.nchips, cfg.hc595.sin, cfg.hc595.sclk, cfg.hc595.latch, cfg.hc595.ena);
+        hc595 = new HC595(
+            wirePinName(cfg.hc595.nchips), 
+            wirePinName(cfg.hc595.sin), 
+            wirePinName(cfg.hc595.sclk), 
+            wirePinName(cfg.hc595.latch), 
+            wirePinName(cfg.hc595.ena));
         hc595->init();
         hc595->update();
     }
@@ -763,13 +886,6 @@
 static int numOutputs;
 static LwOut **lwPin;
 
-// Special output ports:
-//
-//    [0] = Night Mode indicator light
-//
-static LwOut *specialPin[1];
-const int SPECIAL_PIN_NIGHTMODE = 0;
-
 
 // Number of LedWiz emulation outputs.  This is the number of ports
 // accessible through the standard (non-extended) LedWiz protocol
@@ -785,7 +901,7 @@
 static uint8_t *outLevel;
 
 // create a single output pin
-LwOut *createLwPin(LedWizPortCfg &pc, Config &cfg)
+LwOut *createLwPin(int portno, LedWizPortCfg &pc, Config &cfg)
 {
     // get this item's values
     int typ = pc.typ;
@@ -883,6 +999,16 @@
     // If it's gamma-corrected, layer on a gamma corrector
     if (gamma)
         lwp = new LwGammaOut(lwp);
+        
+    // If this is the ZB Launch Ball port, layer a monitor object.  Note
+    // that the nominal port numbering in the cofnig starts at 1, but we're
+    // using an array index, so test against portno+1.
+    if (portno + 1 == cfg.plunger.zbLaunchBall.port)
+        lwp = new LwZbLaunchOut(lwp);
+        
+    // If this is the Night Mode indicator port, layer a night mode object.
+    if (portno + 1 == cfg.nightMode.port)
+        lwp = new LwNightModeIndicatorOut(lwp);
 
     // turn it off initially      
     lwp->set(0);
@@ -923,11 +1049,7 @@
     
     // create the pin interface object for each port
     for (i = 0 ; i < numOutputs ; ++i)
-        lwPin[i] = createLwPin(cfg.outPort[i], cfg);
-        
-    // create the pin interface for each special port
-    for (i = 0 ; i < countof(cfg.specialPort) ; ++i)
-        specialPin[i] = createLwPin(cfg.specialPort[i], cfg);
+        lwPin[i] = createLwPin(i, cfg.outPort[i], cfg);
 }
 
 // LedWiz output states.
@@ -1157,49 +1279,57 @@
     ButtonState()
     {
         di = NULL;
-        on = 0;
-        pressed = prev = 0;
-        dbstate = 0;
-        js = 0;
-        keymod = 0;
-        keycode = 0;
-        special = 0;
+        physState = logState = prevLogState = 0;
+        virtState = 0;
+        dbState = 0;
         pulseState = 0;
-        pulseTime = 0.0f;
+        pulseTime = 0;
     }
     
-    // DigitalIn for the button
+    // "Virtually" press or un-press the button.  This can be used to
+    // control the button state via a software (virtual) source, such as
+    // the ZB Launch Ball feature.
+    //
+    // To allow sharing of one button by multiple virtual sources, each
+    // virtual source must keep track of its own state internally, and 
+    // only call this routine to CHANGE the state.  This is because calls
+    // to this routine are additive: turning the button ON twice will
+    // require turning it OFF twice before it actually turns off.
+    void virtPress(bool on)
+    {
+        // Increment or decrement the current state
+        virtState += on ? 1 : -1;
+    }
+    
+    // DigitalIn for the button, if connected to a physical input
     TinyDigitalIn *di;
     
     // current PHYSICAL on/off state, after debouncing
-    uint8_t on : 1;
+    uint8_t physState : 1;
     
     // current LOGICAL on/off state as reported to the host.
-    uint8_t pressed : 1;
+    uint8_t logState : 1;
 
     // previous logical on/off state, when keys were last processed for USB 
     // reports and local effects
-    uint8_t prev : 1;
+    uint8_t prevLogState : 1;
+    
+    // Virtual press state.  This is used to simulate pressing the button via
+    // software inputs rather than physical inputs.  To allow one button to be
+    // controlled by mulitple software sources, each source should keep track
+    // of its own virtual state for the button independently, and then INCREMENT
+    // this variable when the source's state transitions from off to on, and
+    // DECREMENT it when the source's state transitions from on to off.  That
+    // will make the button's pressed state the logical OR of all of the virtual
+    // and physical source states.
+    uint8_t virtState;
     
     // Debounce history.  On each scan, we shift in a 1 bit to the lsb if
     // the physical key is reporting ON, and shift in a 0 bit if the physical
     // key is reporting OFF.  We consider the key to have a new stable state
     // if we have N consecutive 0's or 1's in the low N bits (where N is
     // a parameter that determines how long we wait for transients to settle).
-    uint8_t dbstate;
-    
-    // joystick button mask for the button, if mapped as a joystick button
-    uint32_t js;
-    
-    // keyboard modifier bits and scan code for the button, if mapped as a keyboard key
-    uint8_t keymod;
-    uint8_t keycode;
-    
-    // media control key code
-    uint8_t mediakey;
-    
-    // special key code
-    uint8_t special;
+    uint8_t dbState;
     
     // Pulse mode: a button in pulse mode transmits a brief logical button press and
     // release each time the attached physical switch changes state.  This is useful
@@ -1220,17 +1350,17 @@
     //
     // Each state change sticks for a minimum period; when the timer expires,
     // if the underlying physical switch is in a different state, we switch
-    // to the next state and restart the timer.  pulseTime is the amount of
-    // time remaining before we can make another state transition.  The state
-    // transitions require a complete cycle, 1 -> 2 -> 3 -> 4 -> 1...; this
-    // guarantees that the parity of the pulse count always matches the 
+    // to the next state and restart the timer.  pulseTime is the time remaining
+    // remaining before we can make another state transition, in microseconds.
+    // The state transitions require a complete cycle, 1 -> 2 -> 3 -> 4 -> 1...; 
+    // this guarantees that the parity of the pulse count always matches the 
     // current physical switch state when the latter is stable, which makes
     // it impossible to "trick" the host by rapidly toggling the switch state.
     // (On my original Pinscape cabinet, I had a hardware pulse generator
     // for coin door, and that *was* possible to trick by rapid toggling.
     // This software system can't be fooled that way.)
     uint8_t pulseState;
-    float pulseTime;
+    uint32_t pulseTime;
     
 } __attribute__((packed)) buttonState[MAX_BUTTONS];
 
@@ -1267,7 +1397,8 @@
     ButtonState *bs = buttonState;
     for (int i = 0 ; i < MAX_BUTTONS ; ++i, ++bs)
     {
-        // if it's connected, check its physical state
+        // 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
@@ -1275,10 +1406,10 @@
             // 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;
+            uint8_t db = bs->dbState;
             db <<= 1;
             db |= (bs->di->read() & 0x01) ^ 0x01;
-            bs->dbstate = db;
+            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
@@ -1286,7 +1417,7 @@
             const uint8_t stable = 0x1F;   // 00011111b -> 5 stable readings
             db &= stable;
             if (db == 0 || db == stable)
-                bs->on = db;
+                bs->physState = db & 1;
         }
     }
 }
@@ -1302,6 +1433,17 @@
     // presume we'll find no keyboard keys
     kbKeys = false;
     
+    // Configure the virtual buttons.  These are buttons controlled via
+    // software triggers rather than physical GPIO inputs.  The virtual
+    // buttons have the same control structures as regular buttons, but
+    // they get their configuration data from other config variables.
+    
+    // ZB Launch Ball button
+    cfg.button[ZBL_BUTTON].set(
+        PINNAME_TO_WIRE(NC),
+        cfg.plunger.zbLaunchBall.keytype,
+        cfg.plunger.zbLaunchBall.keycode);
+    
     // create the digital inputs
     ButtonState *bs = buttonState;
     for (int i = 0 ; i < MAX_BUTTONS ; ++i, ++bs)
@@ -1316,41 +1458,29 @@
             if (cfg.button[i].flags & BtnFlagPulse)
                 bs->pulseState = 1;
             
-            // note if it's a keyboard key of some kind (including media keys)
-            uint8_t val = cfg.button[i].val;
+            // Note if it's a keyboard key of some kind.  If we find any keyboard
+            // mappings, we'll declare a keyboard interface when we send our HID 
+            // configuration to the host during USB connection setup.
             switch (cfg.button[i].typ)
             {
-            case BtnTypeJoystick:
-                // joystick button - get the button bit mask
-                bs->js = 1 << val;
-                break;
-                
             case BtnTypeKey:
-                // regular keyboard key - note the scan code
-                bs->keycode = val;
+                // note that we have at least one keyboard key
                 kbKeys = true;
                 break;
                 
-            case BtnTypeModKey:
-                // keyboard mod key - note the modifier mask
-                bs->keymod = val;
-                kbKeys = true;
-                break;
-                
-            case BtnTypeMedia:
-                // media key - note the code
-                bs->mediakey = val;
-                kbKeys = true;
-                break;
-                
-            case BtnTypeSpecial:
-                // special key
-                bs->special = val;
+            default:
+                // not a keyboard key
                 break;
             }
         }
     }
     
+    // If the ZB Launch Ball feature is enabled, and it uses a keyboard
+    // key, this requires setting up a USB keyboard interface.
+    if (cfg.plunger.zbLaunchBall.port != 0 
+        && cfg.plunger.zbLaunchBall.keytype == BtnTypeKey)
+        kbKeys = true;
+    
     // start the button scan thread
     buttonTicker.attach_us(scanButtons, 1000);
 
@@ -1362,7 +1492,7 @@
 // media control descriptors with the current state of keys mapped to
 // those HID interfaces, and executes the local effects for any keys 
 // mapped to special device functions (e.g., Night Mode).
-void processButtons()
+void processButtons(Config &cfg)
 {
     // start with an empty list of USB key codes
     uint8_t modkeys = 0;
@@ -1376,33 +1506,36 @@
     uint8_t mediakeys = 0;
     
     // calculate the time since the last run
-    float dt = buttonTimer.read();
+    uint32_t dt = buttonTimer.read_us();
     buttonTimer.reset();
 
     // scan the button list
     ButtonState *bs = buttonState;
-    for (int i = 0 ; i < MAX_BUTTONS ; ++i, ++bs)
+    ButtonCfg *bc = cfg.button;
+    for (int i = 0 ; i < MAX_BUTTONS ; ++i, ++bs, ++bc)
     {
         // if it's a pulse-mode switch, get the virtual pressed state
         if (bs->pulseState != 0)
         {
-            // deduct the time to the next state change
-            bs->pulseTime -= dt;
-            if (bs->pulseTime < 0)
-                bs->pulseTime = 0;
-                
             // if the timer has expired, check for state changes
-            if (bs->pulseTime == 0)
+            if (bs->pulseTime > dt)
             {
-                const float pulseLength = 0.2;
+                // not expired yet - deduct the last interval
+                bs->pulseTime -= dt;
+            }
+            else
+            {
+                // pulse time expired - check for a state change
+                const uint32_t pulseLength = 200000UL;  // 200 milliseconds
                 switch (bs->pulseState)
                 {
                 case 1:
                     // off - if the physical switch is now on, start a button pulse
-                    if (bs->on) {
+                    if (bs->physState) 
+                    {
                         bs->pulseTime = pulseLength;
                         bs->pulseState = 2;
-                        bs->pressed = 1;
+                        bs->logState = 1;
                     }
                     break;
                     
@@ -1412,15 +1545,16 @@
                     // change in state in the logical button
                     bs->pulseState = 3;
                     bs->pulseTime = pulseLength;
-                    bs->pressed = 0;
+                    bs->logState = 0;
                     break;
                     
                 case 3:
                     // on - if the physical switch is now off, start a button pulse
-                    if (!bs->on) {
+                    if (!bs->physState) 
+                    {
                         bs->pulseTime = pulseLength;
                         bs->pulseState = 4;
-                        bs->pressed = 1;
+                        bs->logState = 1;
                     }
                     break;
                     
@@ -1428,7 +1562,7 @@
                     // transitioning on to off - end the pulse, and start a gap
                     bs->pulseState = 1;
                     bs->pulseTime = pulseLength;
-                    bs->pressed = 0;
+                    bs->logState = 0;
                     break;
                 }
             }
@@ -1436,44 +1570,102 @@
         else
         {
             // not a pulse switch - the logical state is the same as the physical state
-            bs->pressed = bs->on;
+            bs->logState = bs->physState;
         }
 
         // carry out any edge effects from buttons changing states
-        if (bs->pressed != bs->prev)
+        if (bs->logState != bs->prevLogState)
         {
             // check for special key transitions
-            switch (bs->special)
+            if (cfg.nightMode.btn == i + 1)
             {
-            case 1:
-                // night mode momentary switch - when the button transitions from
-                // OFF to ON, invert night mode
-                if (bs->pressed)
-                    toggleNightMode();
-                break;
-                
-            case 2:
-                // night mode toggle switch - when the button changes state, change
-                // night mode to match the new state
-                setNightMode(bs->pressed);
-                break;
+                // Check the switch type in the config flags.  If flag 0x01 is set,
+                // it's a persistent on/off switch, so the night mode state simply
+                // follows the current state of the switch.  Otherwise, it's a 
+                // momentary button, so each button push (i.e., each transition from
+                // logical state OFF to ON) toggles the current night mode state.
+                if (cfg.nightMode.flags & 0x01)
+                {
+                    // toggle switch - when the button changes state, change
+                    // night mode to match the new state
+                    setNightMode(bs->logState);
+                }
+                else
+                {
+                    // momentary switch - toggle the night mode state when the
+                    // physical button is pushed (i.e., when its logical state
+                    // transitions from OFF to ON)
+                    if (bs->logState)
+                        toggleNightMode();
+                }
             }
             
             // remember the new state for comparison on the next run
-            bs->prev = bs->pressed;
+            bs->prevLogState = bs->logState;
         }
 
-        // if it's pressed, add it to the appropriate key state list
-        if (bs->pressed)
+        // if it's pressed, physically or virtually, add it to the appropriate 
+        // key state list
+        if (bs->logState || bs->virtState)
         {
             // OR in the joystick button bit, mod key bits, and media key bits
-            newjs |= bs->js;
-            modkeys |= bs->keymod;
-            mediakeys |= bs->mediakey;
-            
-            // if it has a keyboard key, add the scan code to the active list
-            if (bs->keycode != 0 && nkeys < 7)
-                keys[nkeys++] = bs->keycode;
+            uint8_t val = bc->val;
+            switch (bc->typ)
+            {
+            case BtnTypeJoystick:
+                // joystick button
+                newjs |= (1 << (val - 1));
+                break;
+                
+            case BtnTypeKey:
+                // Keyboard key.  This could be a modifier key (shift, control,
+                // alt, GUI), a media key (mute, volume up, volume down), or a
+                // regular key.  Check which one.
+                if (val >= 0x7F && val <= 0x81)
+                {
+                    // It's a media key.  OR the key into the media key mask.
+                    // The media mask bits are mapped in the HID report descriptor
+                    // in USBJoystick.cpp.  For simplicity, we arrange the mask so
+                    // that the ones with regular keyboard equivalents that we catch
+                    // here are in the same order as the key scan codes:
+                    //
+                    //   Mute     = scan 0x7F = mask bit 0x01
+                    //   Vol Up   = scan 0x80 = mask bit 0x02
+                    //   Vol Down = scan 0x81 = mask bit 0x04
+                    //
+                    // So we can translate from scan code to bit mask with some
+                    // simple bit shifting:
+                    mediakeys |= (1 << (val - 0x7f));
+                }
+                else if (val >= 0xE0 && val <= 0xE7)
+                {
+                    // It's a modifier key.  Like the media keys, these are represented
+                    // in the USB reports with a bit mask, and like the media keys, we
+                    // arrange the mask bits in the same order as the scan codes.  This
+                    // makes figuring the mask a simple bit shift:
+                    modkeys |= (1 << (val - 0xE0));
+                }
+                else
+                {
+                    // It's a regular key.  Make sure it's not already in the list, and
+                    // that the list isn't full.  If neither of these apply, add the key.
+                    if (nkeys < 7)
+                    {
+                        bool found;
+                        for (int j = 0 ; j < nkeys ; ++j)
+                        {
+                            if (keys[j] == val)
+                            {
+                                found = true;
+                                break;
+                            }
+                        }
+                        if (!found)
+                            keys[nkeys++] = val;
+                    }
+                }
+                break;
+            }
         }
     }
 
@@ -2139,11 +2331,13 @@
 void startTVTimer(Config &cfg)
 {
     // only start the timer if the status sense circuit pins are configured
-    if (cfg.TVON.statusPin != NC && cfg.TVON.latchPin != NC && cfg.TVON.relayPin != NC)
+    if (cfg.TVON.statusPin != 0xFF 
+        && cfg.TVON.latchPin != 0xFF 
+        && cfg.TVON.relayPin != 0xFF)
     {
-        psu2_status_sense = new DigitalIn(cfg.TVON.statusPin);
-        psu2_status_set = new DigitalOut(cfg.TVON.latchPin);
-        tv_relay = new DigitalOut(cfg.TVON.relayPin);
+        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;
     
         // Set up our time routine to run every 1/4 second.  
@@ -2245,10 +2439,12 @@
 static void setNightMode(bool on)
 {
     // set the new night mode flag in the noisy output class
-    LwNoisyOut::nightMode = on;
+    nightMode = on;
 
     // update the special output pin that shows the night mode state
-    specialPin[SPECIAL_PIN_NIGHTMODE]->set(on ? 255 : 0);
+    int port = int(cfg.nightMode.port) - 1;
+    if (port >= 0 && port < numOutputs)
+        lwPin[port]->set(nightMode ? 255 : 0);
 
     // update all outputs for the mode change
     updateAllOuts();
@@ -2257,7 +2453,7 @@
 // Toggle night mode
 static void toggleNightMode()
 {
-    setNightMode(!LwNoisyOut::nightMode);
+    setNightMode(!nightMode);
 }
 
 
@@ -2278,27 +2474,44 @@
     {
     case PlungerType_TSL1410RS:
         // pins are: SI, CLOCK, AO
-        plungerSensor = new PlungerSensorTSL1410R(cfg.plunger.sensorPin[0], cfg.plunger.sensorPin[1], cfg.plunger.sensorPin[2], NC);
+        plungerSensor = new PlungerSensorTSL1410R(
+            wirePinName(cfg.plunger.sensorPin[0]), 
+            wirePinName(cfg.plunger.sensorPin[1]),
+            wirePinName(cfg.plunger.sensorPin[2]),
+            NC);
         break;
         
     case PlungerType_TSL1410RP:
         // pins are: SI, CLOCK, AO1, AO2
-        plungerSensor = new PlungerSensorTSL1410R(cfg.plunger.sensorPin[0], cfg.plunger.sensorPin[1], cfg.plunger.sensorPin[2], cfg.plunger.sensorPin[3]);
+        plungerSensor = new PlungerSensorTSL1410R(
+            wirePinName(cfg.plunger.sensorPin[0]), 
+            wirePinName(cfg.plunger.sensorPin[1]),
+            wirePinName(cfg.plunger.sensorPin[2]), 
+            wirePinName(cfg.plunger.sensorPin[3]));
         break;
         
     case PlungerType_TSL1412RS:
         // pins are: SI, CLOCK, AO1, AO2
-        plungerSensor = new PlungerSensorTSL1412R(cfg.plunger.sensorPin[0], cfg.plunger.sensorPin[1], cfg.plunger.sensorPin[2], NC);
+        plungerSensor = new PlungerSensorTSL1412R(
+            wirePinName(cfg.plunger.sensorPin[0]),
+            wirePinName(cfg.plunger.sensorPin[1]), 
+            wirePinName(cfg.plunger.sensorPin[2]), 
+            NC);
         break;
     
     case PlungerType_TSL1412RP:
         // pins are: SI, CLOCK, AO1, AO2
-        plungerSensor = new PlungerSensorTSL1412R(cfg.plunger.sensorPin[0], cfg.plunger.sensorPin[1], cfg.plunger.sensorPin[2], cfg.plunger.sensorPin[3]);
+        plungerSensor = new PlungerSensorTSL1412R(
+            wirePinName(cfg.plunger.sensorPin[0]), 
+            wirePinName(cfg.plunger.sensorPin[1]), 
+            wirePinName(cfg.plunger.sensorPin[2]), 
+            wirePinName(cfg.plunger.sensorPin[3]));
         break;
     
     case PlungerType_Pot:
         // pins are: AO
-        plungerSensor = new PlungerSensorPot(cfg.plunger.sensorPin[0]);
+        plungerSensor = new PlungerSensorPot(
+            wirePinName(cfg.plunger.sensorPin[0]));
         break;
     
     case PlungerType_None:
@@ -2383,13 +2596,6 @@
         PlungerReading r;
         if (plungerSensor->read(r))
         {
-            // if in calibration mode, apply it to the calibration
-            if (plungerCalMode)
-            {
-                readForCal(r);
-                return;
-            }
-            
             // Pull the previous reading from the history
             const PlungerReading &prv = nthHist(0);
             
@@ -2403,14 +2609,68 @@
             // we're using a fast sensor like that.)
             if (uint32_t(r.t - prv.t) < 2000UL)
                 return;
-                
-            // bounds-check the calibration data
-            checkCalBounds(r.pos);
+
+            // check for calibration mode
+            if (plungerCalMode)
+            {
+                // Calibration mode.  Adjust the calibration bounds to fit
+                // the value.  If this value is beyond the current min or max,
+                // expand the envelope to include this new value.
+                if (r.pos > cfg.plunger.cal.max)
+                    cfg.plunger.cal.max = r.pos;
+                if (r.pos < cfg.plunger.cal.min)
+                    cfg.plunger.cal.min = r.pos;
 
-            // Apply the calibration and rescale to the joystick range.
-            r.pos = int(
-                (long(r.pos - cfg.plunger.cal.zero) * JOYMAX)
-                / (cfg.plunger.cal.max - cfg.plunger.cal.zero));
+                // If we're in calibration state 0, we're waiting for the
+                // plunger to come to rest at the park position so that we
+                // can take a sample of the park position.  Check to see if
+                // we've been at rest for a minimum interval.
+                if (calState == 0)
+                {
+                    if (abs(r.pos - calZeroStart.pos) < 65535/3/50)
+                    {
+                        // we're close enough - make sure we've been here long enough
+                        if (uint32_t(r.t - calZeroStart.t) > 100000UL)
+                        {
+                            // we've been at rest long enough - count it
+                            calZeroPosSum += r.pos;
+                            calZeroPosN += 1;
+                            
+                            // update the zero position from the new average
+                            cfg.plunger.cal.zero = uint16_t(calZeroPosSum / calZeroPosN);
+                            
+                            // switch to calibration state 1 - at rest
+                            calState = 1;
+                        }
+                    }
+                    else
+                    {
+                        // we're not close to the last position - start again here
+                        calZeroStart = r;
+                    }
+                }
+                
+                // Rescale to the joystick range, and adjust for the current
+                // park position, but don't calibrate.  We don't know the maximum
+                // point yet, so we can't calibrate the range.
+                r.pos = int(
+                    (long(r.pos - cfg.plunger.cal.zero) * JOYMAX)
+                    / (65535 - cfg.plunger.cal.zero));
+            }
+            else
+            {
+                // Not in calibration mode.  Apply the existing calibration and 
+                // rescale to the joystick range.
+                r.pos = int(
+                    (long(r.pos - cfg.plunger.cal.zero) * JOYMAX)
+                    / (cfg.plunger.cal.max - cfg.plunger.cal.zero));
+                    
+                // limit the result to the valid joystick range
+                if (r.pos > JOYMAX)
+                    r.pos = JOYMAX;
+                else if (r.pos < -JOYMAX)
+                    r.pos = -JOYMAX;
+            }
 
             // Calculate the velocity from the second-to-last reading
             // to here, in joystick distance units per microsecond.
@@ -2456,9 +2716,14 @@
                 // be strong enough to require the synthetic firing treatment.
                 if (v < 0 && r.pos > JOYMAX/6)
                 {
-                    // enter phase 1
+                    // enter firing phase 1
                     firingMode(1);
                     
+                    // if in calibration state 1 (at rest), switch to state 2 (not 
+                    // at rest)
+                    if (calState == 1)
+                        calState = 2;
+                    
                     // we don't have a freeze position yet, but note the start time
                     f1.pos = 0;
                     f1.t = r.t;
@@ -2470,7 +2735,7 @@
                     // linearly proportional to the starting retraction distance.  
                     // The barrel spring is about 1/6 the length of the main spring, 
                     // so figure it compresses by 1/6 the distance.  (This is overly
-                    // simplistic and inaccurate, but it seems to give perfectly good
+                    // simplistic and not very accurate, but it seems to give good 
                     // visual results, and that's all it's for.)
                     f2.pos = -r.pos/6;
                 }
@@ -2488,6 +2753,25 @@
                     
                     // note the start time for the firing phase
                     f2.t = r.t;
+                    
+                    // if in calibration mode, and we're in state 2 (moving), 
+                    // collect firing statistics for calibration purposes
+                    if (plungerCalMode && calState == 2)
+                    {
+                        // collect a new zero point for the average when we 
+                        // come to rest
+                        calState = 0;
+                        
+                        // collect average firing time statistics in millseconds, if 
+                        // it's in range (20 to 255 ms)
+                        int dt = uint32_t(r.t - f1.t)/1000UL;
+                        if (dt >= 20 && dt <= 255)
+                        {
+                            calRlsTimeSum += dt;
+                            calRlsTimeN += 1;
+                            cfg.plunger.cal.tRelease = uint8_t(calRlsTimeSum / calRlsTimeN);
+                        }
+                    }
                 }
                 else if (v < vprv2)
                 {
@@ -2519,6 +2803,7 @@
                 {
                     // We're not accelerating.  Cancel the firing event.
                     firingMode(0);
+                    calState = 1;
                 }
                 break;
                 
@@ -2578,11 +2863,14 @@
                     f3r.t = r.t;
                 }
 
-                // check if we've come to rest, or close enough
-                if (abs(r.pos - f3s.pos) < 200)
+                // Check if we're close to the last starting point.  The joystick
+                // positive axis range (0..4096) covers the retraction distance of 
+                // about 2.5", so 1" is about 1638 joystick units, hence 1/16" is
+                // about 100 units.
+                if (abs(r.pos - f3s.pos) < 100)
                 {
-                    // It's within an eighth inch of the last starting point. 
-                    // If it's been here for 30ms, consider it stable.
+                    // It's at roughly the same position as the starting point.
+                    // Consider it stable if this has been true for 300ms.
                     if (uint32_t(r.t - f3s.t) > 30000UL)
                     {
                         // we're done with the firing event
@@ -2649,7 +2937,7 @@
                 cfg.plunger.cal.zero = r.pos;
                 
                 // use it as the starting point for the settling watch
-                f1 = r;
+                calZeroStart = r;
             }
             else
             {
@@ -2657,8 +2945,21 @@
                 cfg.plunger.cal.zero = 0xffff/6;
                 
                 // we don't have a starting point for the setting watch
-                f1.pos = -65535;
-                f1.t = 0;
+                calZeroStart.pos = -65535;
+                calZeroStart.t = 0;
+            }
+        }
+        else if (!f && plungerCalMode)
+        {
+            // Leaving calibration mode.  Make sure the max is past the
+            // zero point - if it's not, we'd have a zero or negative
+            // denominator for the scaling calculation, which would be
+            // physically meaningless.
+            if (cfg.plunger.cal.max <= cfg.plunger.cal.zero)
+            {
+                // bad settings - reset to defaults
+                cfg.plunger.cal.max = 0xffff;
+                cfg.plunger.cal.zero = 0xffff/6;
             }
         }
             
@@ -2667,127 +2968,9 @@
     }
     
     // is a firing event in progress?
-    bool isFiring() { return firing > 3; }
+    bool isFiring() { return firing == 3; }
 
 private:
-    // Read the sensor in calibration mode
-    void readForCal(PlungerReading r)
-    {
-        // if it's outside of the current calibration bounds,
-        // expand the bounds
-        if (r.pos < cfg.plunger.cal.min)
-            cfg.plunger.cal.min = r.pos;
-        if (r.pos > cfg.plunger.cal.max)
-            cfg.plunger.cal.max = r.pos;
-                    
-        // While we're in calibration mode, report the raw sensor
-        // position as the joystick value, adjusted to the JOYMAX scale.
-        z = int16_t((long(r.pos) * JOYMAX)/65535);
-        
-        // for the release monitoring, take readings at least 2ms apart
-        if (uint32_t(r.t - f2.t) < 2000UL)
-            return;
-        
-        // Check our state
-        switch (calState)
-        {
-        case 0:
-            // We're waiting for the position to settle.  Check to see if
-            // we've been at the recent settling position long enough.
-            // Consider 1/50" (about 0.5mm) close enough to count as stable, 
-            // to allow for some slight sensor noise from reading to reading.
-            if (abs(r.pos - f1.pos) > 65535/3/50)
-            {
-                // too far away - set the new starting point
-                f1 = r;
-            }
-            else if (uint32_t(r.t - f1.t) > 100000)
-            {
-                // We've been stationary long enough to count as settled.
-                // Wwitch to "at rest" state.
-                calState = 1;
-                
-                // collect the new zero point for our average
-                calZeroPosSum += r.pos;
-                calZeroPosN += 1;
-                
-                // use the new average as the zero point
-                cfg.plunger.cal.zero = uint16_t(calZeroPosSum / calZeroPosN);
-                
-                // remember the current position in f1 to detect when we start
-                // moving again
-                f1 = r;
-            }
-            break;
-            
-        case 1:
-            // At rest.  We remain in this state until we see the plunger
-            // retract more than about 1/2".
-            if (r.pos - f1.pos > 65535/6)
-            {
-                // switch to state 2 - retracting
-                calState = 2;
-                
-                // use f1 as the max so far
-                f1 = r;
-            }
-            break;
-            
-        case 2:
-            // Away from rest position.  Note the maximum point so far in f1,
-            // and monitor for release motions.
-            if (r.pos >= f1.pos)
-            {
-                // moving back - note the new max point on this run
-                f1 = r;
-            }
-            else
-            {
-                // moving forward - switch to possible release mode
-                calState = 3;
-            }
-            break;
-            
-        case 3:
-            // Possible release.  We have to move forward on each new
-            // reading, relative to two readings ago, to stay in release 
-            // mode.
-            if (r.pos >= f3r.pos)
-            {
-                // not moving forward - switch back to retract mode
-                calState = 2;
-                f1 = r;
-            }
-            else if (r.pos <= cfg.plunger.cal.zero)
-            {
-                // Crossed the zero point.  Figure the release time.  If
-                // it's within a reasonable range, add it to the average.
-                // We'll ignore outliers on the assumption that they
-                // don't reflect actual release motions.  
-                int dt = uint32_t(r.t - f1.t)/1000;
-                if (dt < 250 && dt > 25)
-                {
-                    // count it in the average
-                    calRlsTimeSum += dt;
-                    calRlsTimeN += 1;
-                    
-                    // store the new average in the configuration
-                    cfg.plunger.cal.tRelease = uint8_t(calRlsTimeSum / calRlsTimeN);
-                    cfg.plunger.cal.tRelease = dt; // $$$
-                }
-                
-                // release done - switch to "waiting to settle" mode
-                calState = 0;
-                f1 = r;
-            }
-            break;
-        }
-        
-        // f2 is always the immediately previous reading in cal mode, 
-        // and f3r is the one before that
-        f3r = f2;
-        f2 = r;
-    }
 
     // Calibration state.  During calibration mode, we watch for release
     // events, to measure the time it takes to complete the release
@@ -2807,6 +2990,7 @@
     // itself doesn't come to rest at exactly the same spot every time, 
     // largely due to friction in the mechanism.  To calculate the average,
     // we keep a sum of the readings and a count of samples.
+    PlungerReading calZeroStart;
     long calZeroPosSum;
     int calZeroPosN;
     
@@ -2860,53 +3044,6 @@
         return hi;
     }
 
-    // Adjust the calibration bounds for a new reading.  This is used
-    // while NOT in calibration mode to ensure that a reading doesn't
-    // violate the calibration limits.  If it does, we'll readjust the
-    // limits to incorporate the new value.
-    void checkCalBounds(int pos)
-    {
-        // If the value is beyond the calibration maximum, increase the
-        // calibration point.  This ensures that our joystick reading
-        // is always within the valid joystick field range.
-        if (pos > cfg.plunger.cal.max)
-            cfg.plunger.cal.max = pos;
-            
-        // make sure we don't overflow in the opposite direction
-        if (pos < cfg.plunger.cal.zero
-            && cfg.plunger.cal.zero - pos > cfg.plunger.cal.max)
-        {
-            // we need to raise 'max' by this much to keep things in range
-            int adj = cfg.plunger.cal.zero - pos - cfg.plunger.cal.max;
-            
-            // we can raise 'max' at most this much before overflowing
-            int lim = 0xffff - cfg.plunger.cal.max;
-            
-            // if we have headroom to raise 'max' by 'adj', do so, otherwise
-            // raise it as much as we can and apply the excess to lowering the
-            // zero point
-            if (adj > lim)
-            {
-                cfg.plunger.cal.zero -= adj - lim;
-                adj = lim;
-            }
-            cfg.plunger.cal.max += adj;
-        }
-            
-        // If the calibration max isn't higher than the calibration
-        // zero, we have a negative or zero scale range, which isn't
-        // physically meaningful.  Fix it by forcing the max above
-        // the zero point (or the zero point below the max, if they're
-        // both pegged at the datatype maximum).
-        if (cfg.plunger.cal.max <= cfg.plunger.cal.zero)
-        {
-            if (cfg.plunger.cal.zero != 0xFFFF)
-                cfg.plunger.cal.max = cfg.plunger.cal.zero + 1;
-            else
-                cfg.plunger.cal.zero -= 1;
-        }
-    }
-    
     // velocity at previous reading, and the one before that
     float vprv, vprv2;
     
@@ -2939,16 +3076,12 @@
     //   0 - Default state.  We report the real instantaneous plunger 
     //       position to the joystick interface.
     //
-    //   1 - Possible release in progress.  We enter this state when
-    //       we see the plunger start to move forward, and stay in this
-    //       state as long as we see *accelerating* forward motion.
+    //   1 - Moving forward
     //
-    //   2 - Firing event started.  We report the "bounce" position for
-    //       a minimum time.
+    //   2 - Accelerating
     //
-    //   3 - Firing event hold.  We report the rest position for a
-    //       minimum interval, or until the real plunger comes to rest
-    //       somewhere, whichever comes first.
+    //   3 - Firing.  We report the rest position for a minimum interval,
+    //       or until the real plunger comes to rest somewhere.
     //
     int firing;
     
@@ -3026,12 +3159,7 @@
     {
         // start in the default state
         lbState = 0;
-        
-        // get the button bit for the ZB Launch Ball button
-        lbButtonBit = (1 << (cfg.plunger.zbLaunchBall.btn - 1));
-        
-        // start the state transition timer
-        lbTimer.start();
+        btnState = false;
     }
 
     // Update state.  This checks the current plunger position and
@@ -3040,152 +3168,96 @@
     // Updates the simulated button vector according to the current
     // launch ball state.  The main loop calls this before each 
     // joystick update to figure the new simulated button state.
-    void update(uint32_t &simButtons)
+    void update()
     {
-        // Check for a simulated Launch Ball button press, if enabled
-        if (cfg.plunger.zbLaunchBall.port != 0)
+        // If the ZB Launch Ball led wiz output is ON, check for a 
+        // plunger firing event
+        if (zbLaunchOn)
         {                
+            // note the new position
             int znew = plungerReader.getPosition();
-            const int cockThreshold = JOYMAX/3;
+            
+            // figure the push threshold from the configuration data
             const int pushThreshold = int(-JOYMAX/3.0 * cfg.plunger.zbLaunchBall.pushDistance/1000.0);
-            int newState = lbState;
+
+            // check the state
             switch (lbState)
             {
             case 0:
-                // Base state.  If the plunger is pulled back by an inch
-                // or more, go to "cocked" state.  If the plunger is pushed
-                // forward by 1/4" or more, go to "pressed" state.
-                if (znew >= cockThreshold)
-                    newState = 1;
+                // Default state.  If a launch event has been detected on
+                // the plunger, activate a timed pulse and switch to state 1.
+                // If the plunger is pushed forward of the threshold, push
+                // the button.
+                if (plungerReader.isFiring())
+                {
+                    // firing event - start a timed Launch button pulse
+                    lbTimer.reset();
+                    lbTimer.start();
+                    setButton(true);
+                    
+                    // switch to state 1
+                    lbState = 1;
+                }
                 else if (znew <= pushThreshold)
-                    newState = 5;
+                {
+                    // pushed forward without a firing event - hold the
+                    // button as long as we're pushed forward
+                    setButton(true);
+                }
+                else
+                {
+                    // not pushed forward - turn off the Launch button
+                    setButton(false);
+                }
                 break;
                 
             case 1:
-                // Cocked state.  If a firing event is now in progress,
-                // go to "launch" state.  Otherwise, if the plunger is less
-                // than 1" retracted, go to "uncocked" state - the player
-                // might be slowly returning the plunger to rest so as not
-                // to trigger a launch.
-                if (plungerReader.isFiring() || znew <= 0)
-                    newState = 3;
-                else if (znew < cockThreshold)
-                    newState = 2;
+                // State 1: Timed Launch button pulse in progress after a
+                // firing event.  Wait for the timer to expire.
+                if (lbTimer.read_us() > 200000UL)
+                {
+                    // timer expired - turn off the button
+                    setButton(false);
+                    
+                    // switch to state 2
+                    lbState = 2;
+                }
                 break;
                 
             case 2:
-                // Uncocked state.  If the plunger is more than an inch
-                // retracted, return to cocked state.  If we've been in
-                // the uncocked state for more than half a second, return
-                // to the base state.  This allows the user to return the
-                // plunger to rest without triggering a launch, by moving
-                // it at manual speed to the rest position rather than
-                // releasing it.
-                if (znew >= cockThreshold)
-                    newState = 1;
-                else if (lbTimer.read_us() > 500000)
-                    newState = 0;
-                break;
-                
-            case 3:
-                // Launch state.  If the plunger is no longer pushed
-                // forward, switch to launch rest state.
-                if (znew >= 0)
-                    newState = 4;
-                break;    
-                
-            case 4:
-                // Launch rest state.  If the plunger is pushed forward
-                // again, switch back to launch state.  If not, and we've
-                // been in this state for at least 200ms, return to the
-                // default state.
-                if (znew <= pushThreshold)
-                    newState = 3;
-                else if (lbTimer.read_us() > 200000)
-                    newState = 0;                    
-                break;
-                
-            case 5:
-                // Press-and-Hold state.  If the plunger is no longer pushed
-                // forward, AND it's been at least 50ms since we generated
-                // the simulated Launch Ball button press, return to the base 
-                // state.  The minimum time is to ensure that VP has a chance
-                // to see the button press and to avoid transient key bounce
-                // effects when the plunger position is right on the threshold.
-                if (znew > pushThreshold && lbTimer.read_us() > 50000)
-                    newState = 0;
+                // State 2: Timed Launch button pulse done.  Wait for the
+                // plunger launch event to end.
+                if (!plungerReader.isFiring())
+                {
+                    // firing event done - return to default state
+                    lbState = 0;
+                }
                 break;
             }
-            
-            // change states if desired
-            if (newState != lbState)
-            {
-                // If we're entering Launch state OR we're entering the
-                // Press-and-Hold state, AND the ZB Launch Ball LedWiz signal 
-                // is turned on, simulate a Launch Ball button press.
-                if (((newState == 3 && lbState != 4) || newState == 5)
-                    && wizOn[cfg.plunger.zbLaunchBall.port-1])
-                {
-                    lbBtnTimer.reset();
-                    lbBtnTimer.start();
-                    simButtons |= lbButtonBit;
-                }
-                
-                // if we're switching to state 0, release the button
-                if (newState == 0)
-                    simButtons &= ~(1 << (cfg.plunger.zbLaunchBall.btn - 1));
-                
-                // switch to the new state
-                lbState = newState;
+        }
+        else
+        {
+            // ZB Launch Ball disabled - turn off the button if it was on
+            setButton(false);
                 
-                // start timing in the new state
-                lbTimer.reset();
-            }
-            
-            // If the Launch Ball button press is in effect, but the
-            // ZB Launch Ball LedWiz signal is no longer turned on, turn
-            // off the button.
-            //
-            // If we're in one of the Launch states (state #3 or #4),
-            // and the button has been on for long enough, turn it off.
-            // The Launch mode is triggered by a pull-and-release gesture.
-            // From the user's perspective, this is just a single gesture
-            // that should trigger just one momentary press on the Launch
-            // Ball button.  Physically, though, the plunger usually
-            // bounces back and forth for 500ms or so before coming to
-            // rest after this gesture.  That's what the whole state
-            // #3-#4 business is all about - we stay in this pair of
-            // states until the plunger comes to rest.  As long as we're
-            // in these states, we won't send duplicate button presses.
-            // But we also don't want the one button press to continue 
-            // the whole time, so we'll time it out now.
-            //
-            // (This could be written as one big 'if' condition, but
-            // I'm breaking it out verbosely like this to make it easier
-            // for human readers such as myself to comprehend the logic.)
-            if ((simButtons & lbButtonBit) != 0)
-            {
-                int turnOff = false;
-                
-                // turn it off if the ZB Launch Ball signal is off
-                if (!wizOn[cfg.plunger.zbLaunchBall.port-1])
-                    turnOff = true;
-                    
-                // also turn it off if we're in state 3 or 4 ("Launch"),
-                // and the button has been on long enough
-                if ((lbState == 3 || lbState == 4) && lbBtnTimer.read_us() > 250000)
-                    turnOff = true;
-                    
-                // if we decided to turn off the button, do so
-                if (turnOff)
-                {
-                    lbBtnTimer.stop();
-                    simButtons &= ~lbButtonBit;
-                }
-            }
+            // return to the default state
+            lbState = 0;
         }
     }
-  
+    
+    // Set the button state
+    void setButton(bool on)
+    {
+        if (btnState != on)
+        {
+            // remember the new state
+            btnState = on;
+            
+            // update the virtual button state
+            buttonState[ZBL_BUTTON].virtPress(on);
+        }
+    }
+    
 private:
     // Simulated Launch Ball button state.  If a "ZB Launch Ball" port is
     // defined for our LedWiz port mapping, any time that port is turned ON,
@@ -3196,16 +3268,13 @@
     //
     // States:
     //   0 = default
-    //   1 = cocked (plunger has been pulled back about 1" from state 0)
-    //   2 = uncocked (plunger is pulled back less than 1" from state 1)
-    //   3 = launching, plunger is forward beyond park position
-    //   4 = launching, plunger is behind park position
-    //   5 = pressed and holding (plunger has been pressed forward beyond 
-    //       the park position from state 0)
-    int lbState;
+    //   1 = firing (firing event has activated a Launch button pulse)
+    //   2 = firing done (Launch button pulse ended, waiting for plunger
+    //       firing event to end)
+    uint8_t lbState;
     
-    // button bit for ZB launch ball button
-    uint32_t lbButtonBit;
+    // button state
+    bool btnState;
     
     // Time since last lbState transition.  Some of the states are time-
     // sensitive.  In the "uncocked" state, we'll return to state 0 if
@@ -3215,11 +3284,6 @@
     // the Launch Ball button after a moment, and we need to wait for 
     // the plunger to come to rest before returning to state 0.
     Timer lbTimer;
-    
-    // Launch Ball simulated push timer.  We start this when we simulate
-    // the button push, and turn off the simulated button when enough time
-    // has elapsed.
-    Timer lbBtnTimer;
 };
 
 // ---------------------------------------------------------------------------
@@ -3286,8 +3350,8 @@
 // Pixel dump mode - the host requested a dump of image sensor pixels
 // (helpful for installing and setting up the sensor and light source)
 bool reportPlungerStat = false;
-uint8_t reportStatFlags;    // pixel report flag bits (see ccdSensor.h)
-uint8_t reportStatVisMode;  // pixel report visualization mode (not currently used)
+uint8_t reportPlungerStatFlags; // plunger pixel report flag bits (see ccdSensor.h)
+uint8_t reportPlungerStatTime;  // extra exposure time for plunger pixel report
 
 
 // ---------------------------------------------------------------------------
@@ -3313,9 +3377,10 @@
 
 // Handle SET messages - write configuration variables from USB message data
 #define if_msg_valid(test)  if (test)
-#define v_byte(var, ofs)   cfg.var = data[ofs]
-#define v_ui16(var, ofs)   cfg.var = wireUI16(data+ofs)
-#define v_pin(var, ofs)    cfg.var = wirePinName(data[ofs])
+#define v_byte(var, ofs)    cfg.var = data[ofs]
+#define v_ui16(var, ofs)    cfg.var = wireUI16(data+(ofs))
+#define v_pin(var, ofs)     cfg.var = wirePinName(data[ofs])
+#define v_byte_ro(val, ofs) // ignore read-only variables on SET
 #define v_func configVarSet
 #include "cfgVarMsgMap.h"
 
@@ -3324,13 +3389,15 @@
 #undef v_byte
 #undef v_ui16
 #undef v_pin
+#undef v_byte_ro
 #undef v_func
 
 // Handle GET messages - read variable values and return in USB message daa
 #define if_msg_valid(test)
-#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(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_func  configVarGet
 #include "cfgVarMsgMap.h"
 
@@ -3465,10 +3532,10 @@
         case 3:
             // 3 = plunger sensor status report
             //     data[2] = flag bits
-            //     data[3] = visualization mode
+            //     data[3] = extra exposure time, 100us (.1ms) increments
             reportPlungerStat = true;
-            reportStatFlags = data[2];
-            reportStatVisMode = data[3];
+            reportPlungerStatFlags = data[2];
+            reportPlungerStatTime = data[3];
             
             // show purple until we finish sending the report
             diagLED(1, 0, 1);
@@ -3493,17 +3560,16 @@
             // 6 = Save configuration to flash.
             saveConfigToFlash();
             
-            // Reboot the microcontroller.  Nearly all config changes
-            // require a reset, and a reset only takes a few seconds, 
-            // so we don't bother tracking whether or not a reboot is
-            // really needed.
-            reboot(js);
+            // before disconnecting, pause for the delay time specified in
+            // the parameter byte (in seconds)
+            rebootTime_us = data[2] * 1000000L;
+            rebootTimer.start();
             break;
             
         case 7:
             // 7 = Device ID report
-            // (No parameters)
-            js.reportID();
+            //     data[2] = ID index: 1=CPU ID, 2=OpenSDA TUID
+            js.reportID(data[2]);
             break;
             
         case 8:
@@ -3517,10 +3583,12 @@
             //     data[2] = config var ID
             //     data[3] = array index (for array vars: button assignments, output ports)
             {
-                // set up the reply buffer with the variable ID data
+                // set up the reply buffer with the variable ID data, and zero out
+                // the rest of the buffer
                 uint8_t reply[8];
                 reply[1] = data[2];
                 reply[2] = data[3];
+                memset(reply+3, 0, sizeof(reply)-3);
                 
                 // query the value
                 configVarGet(reply);
@@ -3529,6 +3597,11 @@
                 js.reportConfigVar(reply + 1);
             }
             break;
+            
+        case 10:
+            // 10 = Build ID query.
+            js.reportBuildInfo(getBuildID());
+            break;
         }
     }
     else if (data[0] == 66)
@@ -3721,8 +3794,10 @@
     statusFlags = (cfg.plunger.enabled ? 0x01 : 0x00);
 
     // initialize the calibration buttons, if present
-    DigitalIn *calBtn = (cfg.plunger.cal.btn == NC ? 0 : new DigitalIn(cfg.plunger.cal.btn));
-    DigitalOut *calBtnLed = (cfg.plunger.cal.led == NC ? 0 : new DigitalOut(cfg.plunger.cal.led));
+    DigitalIn *calBtn = (cfg.plunger.cal.btn == 0xFF ? 0 : 
+        new DigitalIn(wirePinName(cfg.plunger.cal.btn)));
+    DigitalOut *calBtnLed = (cfg.plunger.cal.led == 0xFF ? 0 :
+        new DigitalOut(wirePinName(cfg.plunger.cal.led)));
 
     // initialize the calibration button 
     calBtnTimer.start();
@@ -3745,14 +3820,6 @@
     // acceleration via the joystick x & y axes, per the VP convention)
     int x = 0, y = 0;
     
-    // Simulated button states.  This is a vector of button states
-    // for the simulated buttons.  We combine this with the physical
-    // button states on each USB joystick report, so we will report
-    // a button as pressed if either the physical button is being pressed
-    // or we're simulating a press on the button.  This is used for the
-    // simulated Launch Ball button.
-    uint32_t simButtons = 0;
-    
     // initialize the plunger sensor
     plungerSensor->init();
     
@@ -3881,12 +3948,12 @@
         // read the plunger sensor
         plungerReader.read();
         
-        // process button updates
-        processButtons();
+        // update the ZB Launch Ball status
+        zbLaunchBall.update();
         
-        // handle the ZB Launch Ball feature
-        zbLaunchBall.update(simButtons);
-
+        // process button updates
+        processButtons(cfg);
+        
         // send a keyboard report if we have new data
         if (kbState.changed)
         {
@@ -3934,10 +4001,7 @@
             // a traditional plunger, so we don't want to confuse VP with
             // regular plunger inputs.
             int z = plungerReader.getPosition();
-            int zrep = (!cfg.plunger.enabled ? 0 :
-                        cfg.plunger.zbLaunchBall.port != 0 
-                          && wizOn[cfg.plunger.zbLaunchBall.port-1] ? 0 :
-                        z);
+            int zrep = (!cfg.plunger.enabled || zbLaunchOn ? 0 : z);
             
             // rotate X and Y according to the device orientation in the cabinet
             accelRotate(x, y);
@@ -3949,7 +4013,7 @@
 #endif
 
             // send the joystick report
-            jsOK = js.update(x, y, zrep, jsButtons | simButtons, statusFlags);
+            jsOK = js.update(x, y, zrep, jsButtons, statusFlags);
             
             // we've just started a new report interval, so reset the timer
             jsReportTimer.reset();
@@ -3959,7 +4023,7 @@
         if (reportPlungerStat)
         {
             // send the report            
-            plungerSensor->sendStatusReport(js, reportStatFlags, reportStatVisMode);
+            plungerSensor->sendStatusReport(js, reportPlungerStatFlags, reportPlungerStatTime);
 
             // we have satisfied this request
             reportPlungerStat = false;
@@ -4053,6 +4117,10 @@
             }
         }
         
+        // if we have a reboot timer pending, check for completion
+        if (rebootTimer.isRunning() && rebootTimer.read_us() > rebootTime_us)
+            reboot(js);
+        
         // if we're disconnected, initiate a new connection
         if (!connected)
         {