![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
work in progress
Dependencies: FastAnalogIn FastIO USBDevice mbed FastPWM SimpleDMA
Fork of Pinscape_Controller by
Diff: main.cpp
- Revision:
- 18:5e890ebd0023
- Parent:
- 17:ab3cec0c8bf4
- Child:
- 19:054f8af32fce
--- a/main.cpp Fri Feb 27 04:14:04 2015 +0000 +++ b/main.cpp Fri Feb 27 07:41:29 2015 +0000 @@ -153,9 +153,10 @@ // long yellow/green = everything's working, but the plunger hasn't // been calibrated; follow the calibration procedure described above. // This flash mode won't appear if the CCD has been disabled. Note -// that the device can't tell whether a CCD is physically attached, -// so you should use the config command to disable the CCD software -// features if you won't be attaching a CCD. +// that the device can't tell whether a CCD is physically attached; +// if you don't have a CCD attached, you can set the appropriate option +// in config.h or use the Windows config tool to disable the CCD +// software features. // // alternating blue/green = everything's working // @@ -442,6 +443,19 @@ // button input map array DigitalIn *buttonDigIn[32]; +// button state +struct ButtonState +{ + // current on/off state + int pressed; + + // Sticky time remaining for current state. When a + // state transition occurs, we set this to a debounce + // period. Future state transitions will be ignored + // until the debounce time elapses. + int t; +} buttonState[32]; + // timer for button reports static Timer buttonTimer; @@ -462,24 +476,67 @@ } -// read the raw button input state -uint32_t readButtonsRaw() +// read the button input state +uint32_t readButtons() { // start with all buttons off uint32_t buttons = 0; + // figure the time elapsed since the last scan + int dt = buttonTimer.read_ms(); + + // reset the timef for the next scan + buttonTimer.reset(); + // scan the button list uint32_t bit = 1; - for (int i = 0 ; i < countof(buttonDigIn) ; ++i, bit <<= 1) + DigitalIn **di = buttonDigIn; + ButtonState *bs = buttonState; + for (int i = 0 ; i < countof(buttonDigIn) ; ++i, ++di, ++bs, bit <<= 1) { - if (buttonDigIn[i] != 0 && !buttonDigIn[i]->read()) - buttons |= bit; + // read this button + if (*di != 0) + { + // deduct the elapsed time since the last update + // from the button's remaining sticky time + bs->t -= dt; + if (bs->t < 0) + bs->t = 0; + + // If the sticky time has elapsed, note the new physical + // state of the button. If we still have sticky time + // remaining, ignore the physical state; the last state + // change persists until the sticky time elapses so that + // we smooth out any "bounce" (electrical transients that + // occur when the switch contact is opened or closed). + if (bs->t == 0) + { + // get the new physical state + int pressed = !(*di)->read(); + + // update the button's logical state if this is a change + if (pressed != bs->pressed) + { + // store the new state + bs->pressed = pressed; + + // start a new sticky period for debouncing this + // state change + bs->t = 1000; + } + } + + // if it's pressed, OR its bit into the state + if (bs->pressed) + buttons |= bit; + } } - // return the button list + // return the new button list return buttons; } +#if 0 // Read buttons with debouncing. // // Debouncing is the process of filtering out transients from button @@ -505,7 +562,7 @@ uint32_t b; // Change mask at this report. This is a bit mask of the buttons - // that *didn't* change on this report. AND this mask with a + // that changed on this report. AND the NOT of this mask with a // new reading to filter buttons out of the new reading that // changed on this report. uint32_t m; @@ -524,19 +581,20 @@ // start timing the next interval buttonTimer.reset(); - // mask out changes for any buttons that changed state within the - // past 50ms - for (int i = 1 ; i < countof(readings) && ms < 50 ; ++i) + // Mask out changes for any buttons that changed state within the + // past 50ms. This ensures that each state change sticks for at + // least 50ms, which should be long enough to be sure that a change + // that reverses a prior change isn't just a transient. + for (int i = 1, j = ri - 1 ; i < countof(readings) && ms < 50 ; ++i, --j) { // find the next prior reading, wrapping in the circular buffer - int j = ri - i; if (j < 0) j = countof(readings) - 1; reading *rj = &readings[j]; // For any button that changed state in the prior reading 'rj', // remove any new change and restore it to its 'rj' state. - b &= rj->m; + b &= ~rj->m; b |= rj->b; // add in the time to the next prior report @@ -547,7 +605,7 @@ uint32_t m = b ^ bPrv; // save the change mask and changed button vector in our history entry - r->m = ~m; + r->m = m; r->b = b & m; // save this as the prior report @@ -561,6 +619,7 @@ // return the debounced result return b; } +#endif // --------------------------------------------------------------------------- // @@ -917,21 +976,6 @@ // --------------------------------------------------------------------------- // -// CCD read interval callback. When reading the CCD, we'll call this -// several times over the course of the read loop to refresh the button -// states. This allows us to debounce the buttons while the long CCD -// read cycle is taking place, so that we can reliably report button -// states after each CCD read cycle. (The read cycle takes about 30ms, -// which should be enough time to reliably debounce the buttons.) -// -void ccdReadCB(void *) -{ - // read the keyboard - readButtonsDebounced(); -} - -// --------------------------------------------------------------------------- -// // Include the appropriate plunger sensor definition. This will define a // class called PlungerSensor, with a standard interface that we use in // the main loop below. This is *kind of* like a virtual class interface, @@ -1185,6 +1229,11 @@ Timer lbTimer; lbTimer.start(); + // 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; + // 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 @@ -1245,12 +1294,11 @@ // host requests for (;;) { - // Look for an incoming report. Continue processing input as - // long as there's anything pending - this ensures that we - // handle input in as timely a fashion as possible by deferring - // output tasks as long as there's input to process. + // Look for an incoming report. Process a few input reports in + // a row, but stop after a few so that a barrage of inputs won't + // starve our output event processing. HID_REPORT report; - while (js.readNB(&report)) + for (int rr = 0 ; rr < 4 && js.readNB(&report) ; ++rr) { // all Led-Wiz reports are 8 bytes exactly if (report.length == 8) @@ -1559,8 +1607,10 @@ } // Check for a simulated Launch Ball button press, if enabled - if (ZBLaunchBallPort != 0 && wizOn[ZBLaunchBallPort-1]) + if (ZBLaunchBallPort != 0) { + const int cockThreshold = JOYMAX/3; + const int pushThreshold = int(-JOYMAX/3 * LaunchBallPushDistance); int newState = lbState; switch (lbState) { @@ -1568,9 +1618,9 @@ // 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 "launch" state. - if (znew >= JOYMAX/3) + if (znew >= cockThreshold) newState = 1; - else if (znew < -JOYMAX/12) + else if (znew <= pushThreshold) newState = 3; break; @@ -1582,7 +1632,7 @@ // to trigger a launch. if (firing || znew <= 0) newState = 3; - else if (znew < JOYMAX/3) + else if (znew < cockThreshold) newState = 2; break; @@ -1590,8 +1640,11 @@ // 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. - if (znew >= JOYMAX/3) + // 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_ms() > 500) newState = 0; @@ -1600,7 +1653,7 @@ case 3: // Launch state. If the plunger is no longer pushed // forward, switch to launch rest state. - if (znew > -JOYMAX/24) + if (znew >= 0) newState = 4; break; @@ -1609,7 +1662,7 @@ // 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 < -JOYMAX/12) + if (znew <= pushThreshold) newState = 3; else if (lbTimer.read_ms() > 200) newState = 0; @@ -1617,11 +1670,18 @@ } // change states if desired + const uint32_t lbButtonBit = (1 << (LaunchBallButton - 1)); if (newState != lbState) { - // if we're entering Launch state, press the Launch Ball button - if (newState == 3 && lbState != 4) - simButtons |= (1 << (LaunchBallButton - 1)); + // if we're entering Launch state, and the ZB Launch Ball + // LedWiz signal is turned on, simulate a Launch Ball button + // press + if (newState == 3 && lbState != 4 && wizOn[ZBLaunchBallPort-1]) + { + lbBtnTimer.reset(); + lbBtnTimer.start(); + simButtons |= lbButtonBit; + } // if we're switching to state 0, release the button if (newState == 0) @@ -1633,6 +1693,17 @@ // start timing in the new state lbTimer.reset(); } + + // if the simulated Launch Ball button press is in effect, + // and either it's been in effect too long or the ZB Launch + // Ball signal is no longer active, turn off the button + if ((simButtons & lbButtonBit) != 0 + && (!wizOn[ZBLaunchBallPort-1] || lbBtnTimer.read_ms() > 250)) + { + lbBtnTimer.stop(); + simButtons &= ~lbButtonBit; + } + } // If a firing event is in progress, generate synthetic reports to @@ -1719,7 +1790,7 @@ } // update the buttons - uint32_t buttons = readButtonsDebounced(); + uint32_t buttons = readButtons(); // If it's been long enough since our last USB status report, // send the new report. We throttle the report rate because