Revision 44:b5ac89b9cd5d, committed 2016-02-07

Comitter:

mjr

Date:

Sun Feb 07 03:07:11 2016 +0000

Parent:

43:7a6364d82a41

Child:

45:c42166b2878c

Commit message:

Work in progress on CCD speed-ups

Changed in this revision

--- a/ccdSensor.h	Sat Feb 06 20:21:48 2016 +0000
+++ b/ccdSensor.h	Sun Feb 07 03:07:11 2016 +0000
@@ -28,9 +28,14 @@
 class PlungerSensorCCD: public PlungerSensor
 {
 public:
-    PlungerSensorCCD(int nativePix, PinName si, PinName clock, PinName ao1, PinName ao2) 
+    PlungerSensorCCD(
+        int nativePix, int highResPix, int lowResPix, 
+        PinName si, PinName clock, PinName ao1, PinName ao2) 
         : ccd(nativePix, si, clock, ao1, ao2)
     {
+        this->highResPix = highResPix;
+        this->lowResPix = lowResPix;
+        this->pix = new uint16_t[highResPix];
     }
     
     // initialize
@@ -42,32 +47,42 @@
     }
     
     // Perform a low-res scan of the sensor.  
-    virtual bool lowResScan(int &pos)
+    virtual bool lowResScan(float &pos)
     {
+        // If we haven't sensed the direction yet, do a high-res scan
+        // first, so that we can get accurate direction data.  Return
+        // the result of the high-res scan if successful, since it 
+        // provides even better data than the caller requested from us.
+        // This will take longer than the caller wanted, but it should
+        // only be necessary to do this once after the system stabilizes
+        // after startup, so the timing difference won't affect normal
+        // operation.
+        if (dir == 0)
+            return highResScan(pos);
+        
         // read the pixels at low resolution
-        uint16_t pix[nlpix];
-        ccd.read(pix, nlpix);
-    
-        // determine which end is brighter
-        uint16_t p1 = pix[0];
-        uint16_t p2 = pix[nlpix-1];
-        int si = 0, di = 1;
-        if (p1 < p2)
-            si = nlpix - 1, di = -1;
+        ccd.read(pix, lowResPix);
         
-        // figure the shadow edge threshold - just use the midpoint 
-        // of the levels at the bright and dark ends
-        uint16_t shadow = uint16_t((long(p1) + long(p2))/2);
+        // set the loop variables for the sensor orientation
+        int si = 0;
+        if (dir < 0)
+            si = lowResPix - 1;
+            
+        // Figure the shadow edge threshold.  Use the midpoint between
+        // the average levels of a few pixels at each end.
+        uint16_t shadow = uint16_t(
+            (long(pix[0]) + long(pix[1]) + long(pix[2])
+             + long(pix[lowResPix-1]) + long(pix[lowResPix-2]) + long(pix[lowResPix-3])
+            )/6);
         
         // find the current tip position
-        for (int n = 0 ; n < nlpix ; ++n, si += di)
+        for (int n = 0 ; n < lowResPix ; ++n, si += dir)
         {
             // check to see if we found the shadow
             if (pix[si] <= shadow)
             {
-                // got it - normalize it to normal 'npix' resolution and
-                // return the result
-                pos = n*npix/nlpix;
+                // got it - normalize to the 0.0..1.0 range and return success
+                pos = float(n)/lowResPix;
                 return true;
             }
         }
@@ -77,24 +92,32 @@
     }
 
     // Perform a high-res scan of the sensor.
-    virtual bool highResScan(int &pos)
+    virtual bool highResScan(float &pos)
     {
         // read the array
-        ccd.read(pix, npix);
+        ccd.read(pix, highResPix);
 
-        // get the brightness at each end of the sensor
-        long b1 = pix[0];
-        long b2 = pix[npix-1];
-        
+        // Sense the orientation of the sensor if we haven't already.  If 
+        // that fails, we must not have enough contrast to find a shadow edge 
+        // in the image, so there's no point in looking any further - just
+        // return failure.
+        if (dir == 0 && !senseOrientation(highResPix))
+            return false;
+            
+        // Get the average brightness for a few pixels at each end.
+        long b1 = (long(pix[0]) + long(pix[1]) + long(pix[2]) + long(pix[3]) + long(pix[4])) / 5;
+        long b2 = (long(pix[highResPix-1]) + long(pix[highResPix-2]) + long(pix[highResPix-3])
+            + long(pix[highResPix-4]) + long(pix[highResPix-5])) / 5;
+
         // Work from the bright end to the dark end.  VP interprets the
         // Z axis value as the amount the plunger is pulled: zero is the
         // rest position, and the axis maximum is fully pulled.  So we 
         // essentially want to report how much of the sensor is lit,
         // since this increases as the plunger is pulled back.
-        int si = 0, di = 1;
+        int si = 0;
         long hi = b1;
-        if (b1 < b2)
-            si = npix - 1, di = -1, hi = b2;
+        if (dir < 0)
+            si = highResPix - 1, hi = b2;
 
         // Figure the shadow threshold.  In practice, the portion of the
         // sensor that's not in shadow has all pixels consistently near
@@ -124,13 +147,13 @@
         if (labs(b1 - b2) > 0x1000)
         {
             uint16_t *pixp = pix + si;           
-            for (int n = 0 ; n < npix ; ++n, pixp += di)
+            for (int n = 0 ; n < highResPix ; ++n, pixp += dir)
             {
                 // if we've crossed the midpoint, report this position
                 if (long(*pixp) < midpt)
                 {
-                    // note the new position
-                    pos = n;
+                    // normalize to the 0.0..1.0 range and return success
+                    pos = float(n)/highResPix;
                     return true;
                 }
             }
@@ -140,6 +163,43 @@
         return false;
     }
     
+    // Infer the sensor orientation from the image data.  This determines 
+    // which end of the array has the brighter pixels.  In some cases it 
+    // might not be possible to tell: if the light source is turned off,
+    // or if the plunger is all the way to one extreme so that the entire
+    // pixel array is in shadow or in full light.  To sense the direction
+    // we need to have a sufficient difference in brightness between the
+    // two ends of the array to be confident that one end is in shadow
+    // and the other isn't.  On success, sets member variable 'dir' and
+    // returns true; on failure (i.e., we don't have sufficient contrast
+    // to sense the orientation), returns false and leaves 'dir' unset.
+    bool senseOrientation(int n)
+    {
+        // get the total brightness for the first few pixels at
+        // each end of the array (a proxy for the average - just
+        // save time by skipping the divide-by-N)
+        long a = long(pix[0]) + long(pix[1]) + long(pix[2]) 
+            + long(pix[3]) + long(pix[4]);
+        long b = long(pix[n-1]) + long(pix[n-2]) + long(pix[n-3])
+            + long(pix[n-4]) + long(pix[n-5]);
+            
+        // if the difference is too small, we can't tell
+        const long minPct = 10;
+        const long minDiff = 65535*5*minPct/100;
+        if (labs(a - b) < minDiff)
+            return false;
+            
+        // we now know the orientation - set the 'dir' member variable
+        // for future use
+        if (a > b)
+            dir = 1;
+        else
+            dir = -1;
+            
+        // success
+        return true;
+    }
+    
     // send an exposure report to the joystick interface
     virtual void sendExposureReport(USBJoystick &js)
     {
@@ -147,13 +207,13 @@
         // gives us the shortest possible exposure for the sample we report,
         // which helps ensure that the user inspecting the data sees something
         // close to what we see when we calculate the plunger position.
-        ccd.read(pix, npix);
-        ccd.read(pix, npix);        
+        ccd.read(pix, highResPix);
+        ccd.read(pix, highResPix);
         
         // send reports for all pixels
         int idx = 0;
-        while (idx < npix)
-            js.updateExposure(idx, npix, pix);
+        while (idx < highResPix)
+            js.updateExposure(idx, highResPix, pix);
             
         // The pixel dump requires many USB reports, since each report
         // can only send a few pixel values.  An integration cycle has
@@ -162,20 +222,27 @@
         // the integration won't be comparable to a normal cycle.  Throw
         // this one away by doing a read now, and throwing it away - that 
         // will get the timing of the *next* cycle roughly back to normal.
-        ccd.read(pix, npix);
+        ccd.read(pix, highResPix);
     }
     
 protected:
-    // pixel buffer - concrete subclasses must set to a buffer of the
-    // appropriate size
+    // pixel buffer - we allocate this to be big enough for a high-res scan
     uint16_t *pix;
+
+    // number of pixels in a high-res scan
+    int highResPix;
+    
+    // number of pixels in a low-res scan
+    int lowResPix;
     
-    // number of pixels in low-res scan - concrete subclasses must set
-    // this to a value that evenly divides the native sensor size
-    int nlpix;
+    // Sensor orientation.  +1 means that the "tip" end - which is always
+    // the brighter end in our images - is at the 0th pixel in the array.
+    // -1 means that the tip is at the nth pixel in the array.  0 means
+    // that we haven't figured it out yet.
+    int dir;
     
+public:
     // the low-level interface to the CCD hardware
-public://$$$
     TSL1410R ccd;
 };
 
@@ -185,21 +252,9 @@
 {
 public:
     PlungerSensorTSL1410R(PinName si, PinName clock, PinName ao1, PinName ao2) 
-        : PlungerSensorCCD(1280, si, clock, ao1, ao2)
+        : PlungerSensorCCD(1280, 320, 64, si, clock, ao1, ao2)
     {
-        // This sensor is 1x1280 pixels at 400dpi.  Sample every 8th
-        // pixel -> 160 pixels at 50dpi == 0.5mm spatial resolution.
-        npix = 320;
-        
-        // for the low-res scan, sample every 40th pixel -> 32 pixels
-        // at 10dpi == 2.54mm spatial resolution.
-        nlpix = 32;
-        
-        // set the pixel buffer
-        pix = pixbuf;
     }
-    
-    uint16_t pixbuf[320];
 };
 
 // TSL1412R
@@ -207,20 +262,7 @@
 {
 public:
     PlungerSensorTSL1412R(PinName si, PinName clock, PinName ao1, PinName ao2)
-        : PlungerSensorCCD(1536, si, clock, ao1, ao2)
+        : PlungerSensorCCD(1536, 384, 64, si, clock, ao1, ao2)
     {
-        // This sensor is 1x1536 pixels at 400dpi.  Sample every 8th
-        // pixel -> 192 pixels at 50dpi == 0.5mm spatial resolution.
-        npix = 192;
-        
-        // for the low-res scan, sample every 48 pixels -> 32 pixels
-        // at 8.34dpi = 3.05mm spatial resolution
-        nlpix = 32;
-        
-        // set the pixel buffer
-        pix = pixbuf;
     }
-    
-    uint16_t pixbuf[192];
 };
-

--- a/config.h	Sat Feb 06 20:21:48 2016 +0000
+++ b/config.h	Sun Feb 07 03:07:11 2016 +0000
@@ -154,8 +154,8 @@
         plunger.cal.btn = NC;
         plunger.cal.led = NC;
         
-        // clear the plunger calibration
-        plunger.cal.reset(4096);
+        // set the default plunger calibration
+        plunger.cal.setDefaults();
         
         // disable the ZB Launch Ball by default
         plunger.zbLaunchBall.port = 0;
@@ -409,17 +409,29 @@
             // compressed by the user pushing on the plunger or by the momentum
             // of a release motion.  The minimum is the maximum forward point where
             // the barrel spring can't be compressed any further.
-            int min;
-            int zero;
-            int max;
+            float min;
+            float zero;
+            float max;
     
-            // reset the plunger calibration
-            void reset(int npix)
+            // Reset the plunger calibration
+            void setDefaults()
             {
-                calibrated = 0;          // not calibrated
-                min = 0;                 // assume we can go all the way forward...
-                max = npix;              // ...and all the way back
-                zero = npix/6;           // the rest position is usually around 1/2" back = 1/6 of total travel
+                calibrated = false;       // not calibrated
+                min = 0.0f;               // assume we can go all the way forward...
+                max = 1.0f;               // ...and all the way back
+                zero = 1.0/6.0f;          // the rest position is usually around 1/2" back = 1/6 of total travel
+            }
+            
+            // Begin calibration.  This sets each limit to the worst
+            // case point - for example, we set the retracted position
+            // to all the way forward.  Each actual reading that comes
+            // in is then checked against the current limit, and if it's
+            // outside of the limit, we reset the limit to the new reading.
+            void begin()
+            {
+                min = 0.0f;               // we don't calibrate the maximum forward position, so keep this at zero
+                zero = 1.0f;              // set the zero position all the way back
+                max = 0.0f;               // set the retracted position all the way forward
             }
 
         } cal;

--- a/main.cpp	Sat Feb 06 20:21:48 2016 +0000
+++ b/main.cpp	Sun Feb 07 03:07:11 2016 +0000
@@ -2503,7 +2503,7 @@
             // enter calibration mode
             calBtnState = 3;
             calBtnTimer.reset();
-            cfg.plunger.cal.reset(plungerSensor->npix);
+            cfg.plunger.cal.begin();
             break;
             
         case 3:
@@ -2765,8 +2765,8 @@
     // acceleration via the joystick x & y axes, per the VP convention)
     int x = 0, y = 0;
     
-    // last plunger report position, in 'npix' normalized pixel units
-    int pos = 0;
+    // last plunger report position, on the 0.0..1.0 normalized scale
+    float pos = 0;
     
     // last plunger report, in joystick units (we report the plunger as the
     // "z" axis of the joystick, per the VP convention)
@@ -2904,8 +2904,8 @@
                     calBtnState = 3;
                     calBtnTimer.reset();
                     
-                    // reset the plunger calibration limits
-                    cfg.plunger.cal.reset(plungerSensor->npix);
+                    // begin the plunger calibration limits
+                    cfg.plunger.cal.begin();
                 }
                 break;
                 
@@ -2978,32 +2978,35 @@
             }
         }
  
-        // If the plunger is enabled, and we're not already in a firing event,
-        // and the last plunger reading had the plunger pulled back at least
-        // a bit, watch for plunger release events until it's time for our next
-        // USB report.
-        if (!firing && cfg.plunger.enabled && z >= JOYMAX/6)
+        // If the plunger is enabled, and we're not in calibration mode, and 
+        // we're not already in a firing event, and the last plunger reading had 
+        // the plunger pulled back at least a bit, watch for plunger release 
+        // events until it's time for our next USB report.
+        if (!firing && calBtnState != 3 && cfg.plunger.enabled && z >= JOYMAX/6)
         {
             // monitor the plunger until it's time for our next report
-            while (jsReportTimer.read_ms() < 15)
+            for (int i = 0 ; i < 20 && jsReportTimer.read_ms() < 12 ; ++i)
             {
                 // do a fast low-res scan; if it's at or past the zero point,
                 // start a firing event
-                int pos0;
+                float pos0;
                 if (plungerSensor->lowResScan(pos0) && pos0 <= cfg.plunger.cal.zero)
+                {
                     firing = 1;
+                    break;
+                }
             }
         }
 
-        // read the plunger sensor, if it's enabled
-        if (cfg.plunger.enabled)
+        // read the plunger sensor, if it's enabled and we're not in firing mode
+        if (cfg.plunger.enabled && !firing)
         {
             // start with the previous reading, in case we don't have a
             // clear result on this frame
             int znew = z;
             if (plungerSensor->highResScan(pos))
             {
-                // We got a new reading.  If we're in calibration mode, use it
+                // We have a new reading.  If we're in calibration mode, use it
                 // to figure the new calibration, otherwise adjust the new reading
                 // for the established calibration.
                 if (calBtnState == 3)
@@ -3018,7 +3021,7 @@
                         cfg.plunger.cal.max = pos;
                         
                     // normalize to the full physical range while calibrating
-                    znew = int(round(float(pos)/plungerSensor->npix * JOYMAX));
+                    znew = int(round(pos * JOYMAX));
                 }
                 else
                 {
@@ -3032,8 +3035,10 @@
                     // values represent travel in the push direction.
                     if (pos > cfg.plunger.cal.max)
                         pos = cfg.plunger.cal.max;
-                    znew = int(round(float(pos - cfg.plunger.cal.zero)
-                        / (cfg.plunger.cal.max - cfg.plunger.cal.zero + 1) * JOYMAX));
+                    znew = int(round(
+                        (pos - cfg.plunger.cal.zero)
+                        / (cfg.plunger.cal.max - cfg.plunger.cal.zero) 
+                        * JOYMAX));
                 }
             }
 
@@ -3049,7 +3054,7 @@
                 // The plunger has moved forward since the previous report.
                 // Watch it for a few more ms to see if we can get a stable
                 // new position.
-                int pos0;
+                float pos0;
                 if (plungerSensor->lowResScan(pos0))
                 {
                     int pos1 = pos0;
@@ -3058,16 +3063,15 @@
                     while (tw.read_ms() < 6)
                     {
                         // read the new position
-                        int pos2;
+                        float pos2;
                         if (plungerSensor->lowResScan(pos2))
                         {
                             // If it's stable over consecutive readings, stop looping.
-                            // (Count it as stable if the position is within about 1/8".
-                            // pos1 and pos2 are reported in pixels, so they range from
-                            // 0 to npix.  The overall travel of a standard plunger is
-                            // about 3.2", so we have (npix/3.2) pixels per inch, hence
-                            // 1/8" is (npix/3.2)*(1/8) pixels.)
-                            if (abs(pos2 - pos1) < int(plungerSensor->npix/(3.2*8)))
+                            // Count it as stable if the position is within about 1/8".
+                            // The overall travel of a standard plunger is about 3.2", 
+                            // so on our normalized 0.0..1.0 scale, 1.0 equals 3.2",
+                            // thus 1" = .3125 and 1/8" = .0391.
+                            if (fabs(pos2 - pos1) < .0391f)
                                 break;
         
                             // If we've crossed the rest position, and we've moved by
@@ -3083,8 +3087,7 @@
                             // to the first reading of the loop - we don't require the
                             // threshold motion over consecutive readings, but any time
                             // over the stability wait loop.
-                            if (pos1 < cfg.plunger.cal.zero
-                                && abs(pos2 - pos0) > int(plungerSensor->npix/(3.2*8)))
+                            if (pos1 < cfg.plunger.cal.zero && fabs(pos2 - pos0) > .0391f)
                             {
                                 firing = 1;
                                 break;

--- a/nullSensor.h	Sat Feb 06 20:21:48 2016 +0000
+++ b/nullSensor.h	Sun Feb 07 03:07:11 2016 +0000
@@ -14,8 +14,8 @@
     PlungerSensorNull() { }
     
     virtual void init() { }
-    virtual bool lowResScan(int &pos) { return false; }
-    virtual bool highResScan(int &pos) { return false; }
+    virtual bool lowResScan(float &pos) { return false; }
+    virtual bool highResScan(float &pos) { return false; }
 };
 
 #endif /* NULLSENSOR_H */

--- a/plunger.h	Sat Feb 06 20:21:48 2016 +0000
+++ b/plunger.h	Sun Feb 07 03:07:11 2016 +0000
@@ -15,48 +15,23 @@
     PlungerSensor() { }
     virtual ~PlungerSensor() { }
     
-    // Number of "pixels" in the sensor's range.  We use the term "pixels"
-    // here for historical reasons, namely that the first sensor we implemented
-    // was an imaging sensor that physically sensed the plunger position as
-    // a pixel coordinate in the image.  But it's no longer the right word,
-    // since we support sensor types that have nothing to do with imaging.
-    // Even so, the function this serves is still applicable.  Abstractly,
-    // it represents the physical resolution of the sensor in terms of
-    // the number of quanta over the full range of travel of the plunger.
-    // For sensors that inherently quantize the position reading at the 
-    // physical level, such as imaging sensors and quadrature sensors, 
-    // this should be set to the total number of position steps over the 
-    // range of travel.  For devices with physically analog outputs, such 
-    // as potentiometers or LVDTs, the reading still has to be digitized 
-    // for us to be able to work with it, which means it has to be turned
-    // into a value that's fundamentally an integer.  But this happens in
-    // the ADC, so the quantization scale is hidden in the mbed libraries.
-    // The normal KL25Z ADC configuration is 16-bit quantization, so the
-    // quantization factor is usually 65535.  But you might prefer to set
-    // this to the joystick maximum so that there are no more rounding
-    // errors in scale conversions after the point of initial conversion.
-    //
-    // IMPORTANT!  This value MUST be initialized in the constructor for
-    // each concrete subclass.
-    int npix;
-         
     // Initialize the physical sensor device.  This is called at startup
     // to set up the device for first use.
     virtual void init() = 0;
 
     // Take a high-resolution reading.  Sets pos to the current position,
-    // on a scale from 0 to npix:  0 is the maximum forward plunger position,
-    // and npix is the maximum retracted position, in terms of the sensor's
+    // on a scale from 0.0 to 1.0:  0.0 is the maximum forward plunger position,
+    // and 1.0 is the maximum retracted position, in terms of the sensor's
     // extremes.  This is a raw reading in terms of the sensor range; the
     // caller is responsible for applying calibration data and scaling the
     // result to the the joystick report range.
     //
     // Returns true on success, false on failure.  Return false if it wasn't
     // possible to take a good reading for any reason.
-    virtual bool highResScan(int &pos) = 0;
+    virtual bool highResScan(float &pos) = 0;
 
     // Take a low-resolution reading.  This reports the result on the same
-    // 0..npix scale as highResScan().  Returns true on success, false on
+    // 0.0 to 1.0 scale as highResScan().  Returns true on success, false on
     // failure.
     //
     // The difference between the high-res and low-res scans is the amount 
@@ -67,7 +42,7 @@
     // The distinction is for the benefit of sensors that need significantly
     // longer to read at higher resolutions, such as image sensors that have
     // to sample pixels serially.
-    virtual bool lowResScan(int &pos) = 0;
+    virtual bool lowResScan(float &pos) = 0;
         
     // Send an exposure report to the joystick interface.  This is specifically
     // for image sensors, and should be omitted by other sensor types.  For

--- a/potSensor.h	Sat Feb 06 20:21:48 2016 +0000
+++ b/potSensor.h	Sun Feb 07 03:07:11 2016 +0000
@@ -23,20 +23,9 @@
     
     virtual void init() 
     {
-        // The potentiometer doesn't have pixels, but we still need an
-        // integer range for normalizing our digitized voltage level values.
-        // The number here is fairly arbitrary; the higher it is, the finer
-        // the digitized steps.  A 40" 1080p HDTV has about 55 pixels per inch
-        // on its physical display, so if the on-screen plunger is displayed
-        // at roughly the true physical size, it's about 3" on screen or about
-        // 165 pixels.  So the minimum quantization size here should be about
-        // the same.  For the pot sensor, this is just a scaling factor, 
-        // so higher values don't cost us anything (unlike the CCD, where the
-        // read time is proportional to the number of pixels we sample).
-        npix = 4096;
     }
     
-    virtual bool highResScan(int &pos)
+    virtual bool highResScan(float &pos)
     {
         // Take a few readings and use the average, to reduce the effect
         // of analog voltage fluctuations.  The voltage range on the ADC
@@ -47,21 +36,21 @@
         // So 1.5% noise is big enough to be visible in the joystick
         // reports.  Averaging several readings should help smooth out
         // random noise in the readings.
-        pos = int((pot.read() + pot.read() + pot.read())/3.0 * npix);
+        //
+        // Readings through the standard AnalogIn class take about 30us
+        // each, so 5 readings is about 150us.  This is plenty fast enough
+        // for even a low-res scan.
+        pos = (pot.read() + pot.read() + pot.read() + pot.read() + pot.read())/5.0;
         return true;
     }
     
-    virtual bool lowResScan(int &pos)
+    virtual bool lowResScan(float &pos)
     {
-        // Use an average of several readings.  Note that even though this
-        // is nominally a "low res" scan, we can still afford to take an
-        // average.  The point of the low res interface is to speed things
-        // up for the image sensor types, which have a large number of
-        // analog samples to read.  In our case, we only have the one
-        // input to sample, so our normal scan is already so fast that
-        // there's no need to do anything different here.
-        pos = int((pot.read() + pot.read() + pot.read())/3.0 * npix);
-        return true;
+        // Since we have only one analog input to sample, our read time is
+        // very fast compared to the image sensor alternatives, so there's no
+        // need to do anything different for a faster low-res scan.  Simply
+        // take a normal high-res reading.
+        return highResScan(pos);
     }
         
 private: