Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

Plunger/plunger.h@91:ae9be42652bf, 2017-10-20 (annotated)

Committer:
mjr
Date:
Fri Oct 20 06:21:40 2017 +0000
Revision:
91:ae9be42652bf
Parent:
87:8d35c74403af
Child:
100:1ff35c07217c
Add plunger reverse orientation filter

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mjr 82:4f6209cb5c33 1 // Plunger Sensor Interface
mjr 82:4f6209cb5c33 2 //
mjr 82:4f6209cb5c33 3 // This module defines the abstract interface to the plunger sensors.
mjr 82:4f6209cb5c33 4 // We support several different physical sensor types, so we need a
mjr 82:4f6209cb5c33 5 // common interface for use in the main code.
mjr 82:4f6209cb5c33 6 //
mjr 82:4f6209cb5c33 7 // In case it's helpful in developing code for new sensor types, I've
mjr 82:4f6209cb5c33 8 // measured the maximum instantaneous speed of a plunger at .175 inches
mjr 82:4f6209cb5c33 9 // per millisecond, or 4.46 mm/ms. (I measured that with an AEDR-8300;
mjr 82:4f6209cb5c33 10 // see that code for more details.)
mjr 82:4f6209cb5c33 11 //
mjr 82:4f6209cb5c33 12
mjr 82:4f6209cb5c33 13 #ifndef PLUNGER_H
mjr 82:4f6209cb5c33 14 #define PLUNGER_H
mjr 82:4f6209cb5c33 15
mjr 87:8d35c74403af 16 #include "config.h"
mjr 87:8d35c74403af 17
mjr 82:4f6209cb5c33 18 // Plunger reading with timestamp
mjr 82:4f6209cb5c33 19 struct PlungerReading
mjr 82:4f6209cb5c33 20 {
mjr 82:4f6209cb5c33 21 // Raw sensor reading, normalied to 0x0000..0xFFFF range
mjr 82:4f6209cb5c33 22 int pos;
mjr 82:4f6209cb5c33 23
mjr 82:4f6209cb5c33 24 // Rimestamp of reading, in microseconds, relative to an arbitrary
mjr 82:4f6209cb5c33 25 // zero point. Note that a 32-bit int can only represent about 71.5
mjr 82:4f6209cb5c33 26 // minutes worth of microseconds, so this value is only meaningful
mjr 82:4f6209cb5c33 27 // to compute a delta from other recent readings. As long as two
mjr 82:4f6209cb5c33 28 // readings are within 71.5 minutes of each other, the time difference
mjr 82:4f6209cb5c33 29 // calculated from the timestamps using 32-bit math will be correct
mjr 82:4f6209cb5c33 30 // *even if a rollover occurs* between the two readings, since the
mjr 82:4f6209cb5c33 31 // calculation is done mod 2^32-1.
mjr 82:4f6209cb5c33 32 uint32_t t;
mjr 82:4f6209cb5c33 33 };
mjr 82:4f6209cb5c33 34
mjr 82:4f6209cb5c33 35 class PlungerSensor
mjr 82:4f6209cb5c33 36 {
mjr 82:4f6209cb5c33 37 public:
mjr 86:e30a1f60f783 38 PlungerSensor(int nativeScale)
mjr 86:e30a1f60f783 39 {
mjr 86:e30a1f60f783 40 // use the joystick scale as our native scale by default
mjr 86:e30a1f60f783 41 this->nativeScale = nativeScale;
mjr 86:e30a1f60f783 42
mjr 86:e30a1f60f783 43 // figure the scaling factor
mjr 86:e30a1f60f783 44 scalingFactor = (65535UL*65536UL) / nativeScale;
mjr 86:e30a1f60f783 45
mjr 86:e30a1f60f783 46 // presume no jitter filter
mjr 86:e30a1f60f783 47 jfWindow = 0;
mjr 86:e30a1f60f783 48
mjr 86:e30a1f60f783 49 // initialize the jitter filter
mjr 86:e30a1f60f783 50 jfLo = jfHi = jfLast = 0;
mjr 91:ae9be42652bf 51
mjr 91:ae9be42652bf 52 // presume normal orientation
mjr 91:ae9be42652bf 53 reverseOrientation = false;
mjr 86:e30a1f60f783 54 }
mjr 82:4f6209cb5c33 55
mjr 82:4f6209cb5c33 56 // ---------- Abstract sensor interface ----------
mjr 82:4f6209cb5c33 57
mjr 82:4f6209cb5c33 58 // Initialize the physical sensor device. This is called at startup
mjr 82:4f6209cb5c33 59 // to set up the device for first use.
mjr 82:4f6209cb5c33 60 virtual void init() { }
mjr 82:4f6209cb5c33 61
mjr 82:4f6209cb5c33 62 // Auto-zero the plunger. Relative sensor types, such as quadrature
mjr 82:4f6209cb5c33 63 // sensors, can lose sync with the absolute position over time if they
mjr 82:4f6209cb5c33 64 // ever miss any motion. We can automatically correct for this by
mjr 82:4f6209cb5c33 65 // resetting to the park position after periods of inactivity. It's
mjr 82:4f6209cb5c33 66 // usually safe to assume that the plunger is at the park position if it
mjr 82:4f6209cb5c33 67 // hasn't moved in a long time, since the spring always returns it to
mjr 82:4f6209cb5c33 68 // that position when it isn't being manipulated. The main loop monitors
mjr 82:4f6209cb5c33 69 // for motion, and calls this after a long enough time goes by without
mjr 82:4f6209cb5c33 70 // seeing any movement. Sensor types that are inherently absolute
mjr 82:4f6209cb5c33 71 // (TSL1410, potentiometers) shouldn't do anything here.
mjr 82:4f6209cb5c33 72 virtual void autoZero() { }
mjr 82:4f6209cb5c33 73
mjr 82:4f6209cb5c33 74 // Is the sensor ready to take a reading? The optical sensor requires
mjr 82:4f6209cb5c33 75 // a fairly long time (2.5ms) to transfer the data for each reading, but
mjr 82:4f6209cb5c33 76 // this is done via DMA, so we can carry on other work while the transfer
mjr 82:4f6209cb5c33 77 // takes place. This lets us poll the sensor to see if it's still busy
mjr 82:4f6209cb5c33 78 // working on the current reading's data transfer.
mjr 82:4f6209cb5c33 79 virtual bool ready() { return true; }
mjr 82:4f6209cb5c33 80
mjr 87:8d35c74403af 81 // Is a plunger DMA operation in progress?
mjr 87:8d35c74403af 82 virtual bool dmaBusy() { return false; }
mjr 87:8d35c74403af 83
mjr 82:4f6209cb5c33 84 // Read the sensor position, if possible. Returns true on success,
mjr 82:4f6209cb5c33 85 // false if it wasn't possible to take a reading. On success, fills
mjr 86:e30a1f60f783 86 // in 'r' with the current reading and timestamp and returns true.
mjr 86:e30a1f60f783 87 // Returns false if a reading couldn't be taken.
mjr 82:4f6209cb5c33 88 //
mjr 86:e30a1f60f783 89 // r.pos is set to the normalized position reading, and r.t is set to
mjr 86:e30a1f60f783 90 // the timestamp of the reading.
mjr 82:4f6209cb5c33 91 //
mjr 86:e30a1f60f783 92 // The normalized position is the sensor reading, corrected for jitter,
mjr 86:e30a1f60f783 93 // and adjusted to the abstract 0x0000..0xFFFF range.
mjr 86:e30a1f60f783 94 //
mjr 86:e30a1f60f783 95 // The timestamp is the time the sensor reading was taken, relative to
mjr 86:e30a1f60f783 96 // an arbitrary zero point. The arbitrary zero point makes this useful
mjr 86:e30a1f60f783 97 // only for calculating the time between readings. Note that the 32-bit
mjr 86:e30a1f60f783 98 // timestamp rolls over about every 71 minutes, so it should only be
mjr 86:e30a1f60f783 99 // used for time differences between readings taken fairly close together.
mjr 86:e30a1f60f783 100 // In practice, the higher level code only uses this for a few consecutive
mjr 86:e30a1f60f783 101 // readings to calculate (nearly) instantaneous velocities, so the time
mjr 86:e30a1f60f783 102 // spans are only tens of milliseconds.
mjr 82:4f6209cb5c33 103 //
mjr 82:4f6209cb5c33 104 // Timing requirements: for best results, readings should be taken
mjr 86:e30a1f60f783 105 // in well under 5ms. The release motion of the physical plunger
mjr 86:e30a1f60f783 106 // takes from 30ms to 50ms, so we need to collect samples much faster
mjr 86:e30a1f60f783 107 // than that to avoid aliasing during the bounce.
mjr 86:e30a1f60f783 108 bool read(PlungerReading &r)
mjr 86:e30a1f60f783 109 {
mjr 86:e30a1f60f783 110 // get the raw reading
mjr 86:e30a1f60f783 111 if (readRaw(r))
mjr 86:e30a1f60f783 112 {
mjr 91:ae9be42652bf 113 // adjust for orientation
mjr 91:ae9be42652bf 114 r.pos = applyOrientation(r.pos);
mjr 91:ae9be42652bf 115
mjr 86:e30a1f60f783 116 // process it through the jitter filter
mjr 87:8d35c74403af 117 r.pos = jitterFilter(r.pos);
mjr 86:e30a1f60f783 118
mjr 86:e30a1f60f783 119 // adjust to the abstract scale via the scaling factor
mjr 86:e30a1f60f783 120 r.pos = uint16_t(uint32_t((scalingFactor * r.pos) + 32768) >> 16);
mjr 86:e30a1f60f783 121
mjr 86:e30a1f60f783 122 // success
mjr 86:e30a1f60f783 123 return true;
mjr 86:e30a1f60f783 124 }
mjr 86:e30a1f60f783 125 else
mjr 86:e30a1f60f783 126 {
mjr 86:e30a1f60f783 127 // no reading is available
mjr 86:e30a1f60f783 128 return false;
mjr 86:e30a1f60f783 129 }
mjr 86:e30a1f60f783 130 }
mjr 86:e30a1f60f783 131
mjr 86:e30a1f60f783 132 // Get a raw plunger reading. This gets the raw sensor reading with
mjr 86:e30a1f60f783 133 // timestamp, without jitter filtering and without any scale adjustment.
mjr 86:e30a1f60f783 134 virtual bool readRaw(PlungerReading &r) = 0;
mjr 82:4f6209cb5c33 135
mjr 82:4f6209cb5c33 136 // Begin calibration. The main loop calls this when the user activates
mjr 82:4f6209cb5c33 137 // calibration mode. Sensors that work in terms of relative positions,
mjr 82:4f6209cb5c33 138 // such as quadrature-based sensors, can use this to set the reference
mjr 82:4f6209cb5c33 139 // point for the park position internally.
mjr 82:4f6209cb5c33 140 virtual void beginCalibration() { }
mjr 82:4f6209cb5c33 141
mjr 82:4f6209cb5c33 142 // Send a sensor status report to the host, via the joystick interface.
mjr 82:4f6209cb5c33 143 // This provides some common information for all sensor types, and also
mjr 82:4f6209cb5c33 144 // includes a full image snapshot of the current sensor pixels for
mjr 82:4f6209cb5c33 145 // imaging sensor types.
mjr 82:4f6209cb5c33 146 //
mjr 82:4f6209cb5c33 147 // The default implementation here sends the common information
mjr 82:4f6209cb5c33 148 // packet, with the pixel size set to 0.
mjr 82:4f6209cb5c33 149 //
mjr 82:4f6209cb5c33 150 // 'flags' is a combination of bit flags:
mjr 82:4f6209cb5c33 151 // 0x01 -> low-res scan (default is high res scan)
mjr 82:4f6209cb5c33 152 //
mjr 82:4f6209cb5c33 153 // Low-res scan mode means that the sensor should send a scaled-down
mjr 82:4f6209cb5c33 154 // image, at a reduced size determined by the sensor subtype. The
mjr 82:4f6209cb5c33 155 // default if this flag isn't set is to send the full image, at the
mjr 82:4f6209cb5c33 156 // sensor's native pixel size. The low-res version is a reduced size
mjr 82:4f6209cb5c33 157 // image in the normal sense of scaling down a photo image, keeping the
mjr 82:4f6209cb5c33 158 // image intact but at reduced resolution. Note that low-res mode
mjr 82:4f6209cb5c33 159 // doesn't affect the ongoing sensor operation at all. It only applies
mjr 82:4f6209cb5c33 160 // to this single pixel report. The purpose is simply to reduce the USB
mjr 82:4f6209cb5c33 161 // transmission time for the image, to allow for a faster frame rate for
mjr 82:4f6209cb5c33 162 // displaying the sensor image in real time on the PC. For a high-res
mjr 82:4f6209cb5c33 163 // sensor like the TSL1410R, sending the full pixel array by USB takes
mjr 82:4f6209cb5c33 164 // so long that the frame rate is way below regular video rates.
mjr 82:4f6209cb5c33 165 //
mjr 82:4f6209cb5c33 166 // 'exposureTime' is the amount of extra time to add to the exposure,
mjr 82:4f6209cb5c33 167 // in 100us (.1ms) increments. For imaging sensors, the frame we report
mjr 82:4f6209cb5c33 168 // is exposed for the minimum exposure time plus this added time. This
mjr 82:4f6209cb5c33 169 // allows the host to take readings at different exposure levels for
mjr 82:4f6209cb5c33 170 // calibration purposes. Non-imaging sensors ignore this.
mjr 82:4f6209cb5c33 171 virtual void sendStatusReport(
mjr 82:4f6209cb5c33 172 class USBJoystick &js, uint8_t flags, uint8_t exposureTime)
mjr 82:4f6209cb5c33 173 {
mjr 82:4f6209cb5c33 174 // read the current position
mjr 82:4f6209cb5c33 175 int pos = 0xFFFF;
mjr 82:4f6209cb5c33 176 PlungerReading r;
mjr 86:e30a1f60f783 177 if (readRaw(r))
mjr 82:4f6209cb5c33 178 {
mjr 91:ae9be42652bf 179 // adjust for reverse orientation
mjr 91:ae9be42652bf 180 r.pos = applyOrientation(r.pos);
mjr 91:ae9be42652bf 181
mjr 86:e30a1f60f783 182 // success - apply the jitter filter
mjr 86:e30a1f60f783 183 pos = jitterFilter(r.pos);
mjr 82:4f6209cb5c33 184 }
mjr 82:4f6209cb5c33 185
mjr 82:4f6209cb5c33 186 // Send the common status information, indicating 0 pixels, standard
mjr 82:4f6209cb5c33 187 // sensor orientation, and zero processing time. Non-imaging sensors
mjr 86:e30a1f60f783 188 // usually don't have any way to detect the orientation, so assume
mjr 86:e30a1f60f783 189 // normal orientation (flag 0x01). Also assume zero analysis time,
mjr 86:e30a1f60f783 190 // as most non-image sensors don't have to do anything CPU-intensive
mjr 86:e30a1f60f783 191 // with the raw readings (all they usually have to do is scale the
mjr 86:e30a1f60f783 192 // value to the abstract reporting range).
mjr 86:e30a1f60f783 193 js.sendPlungerStatus(0, pos, 0x01, getAvgScanTime(), 0);
mjr 86:e30a1f60f783 194 js.sendPlungerStatus2(nativeScale, jfLo, jfHi, r.pos, 0);
mjr 82:4f6209cb5c33 195 }
mjr 82:4f6209cb5c33 196
mjr 82:4f6209cb5c33 197 // Get the average sensor scan time in microseconds
mjr 82:4f6209cb5c33 198 virtual uint32_t getAvgScanTime() = 0;
mjr 91:ae9be42652bf 199
mjr 91:ae9be42652bf 200 // Apply the orientation filter. The position is in unscaled
mjr 91:ae9be42652bf 201 // native sensor units.
mjr 91:ae9be42652bf 202 int applyOrientation(int pos)
mjr 91:ae9be42652bf 203 {
mjr 91:ae9be42652bf 204 return (reverseOrientation ? nativeScale - pos : pos);
mjr 91:ae9be42652bf 205 }
mjr 82:4f6209cb5c33 206
mjr 91:ae9be42652bf 207 // Apply the jitter filter. The position is in unscaled native
mjr 91:ae9be42652bf 208 // sensor units.
mjr 86:e30a1f60f783 209 int jitterFilter(int pos)
mjr 86:e30a1f60f783 210 {
mjr 86:e30a1f60f783 211 // Check to see where the new reading is relative to the
mjr 86:e30a1f60f783 212 // current window
mjr 86:e30a1f60f783 213 if (pos < jfLo)
mjr 86:e30a1f60f783 214 {
mjr 86:e30a1f60f783 215 // the new position is below the current window, so move
mjr 86:e30a1f60f783 216 // the window down such that the new point is at the bottom
mjr 86:e30a1f60f783 217 // of the window
mjr 86:e30a1f60f783 218 jfLo = pos;
mjr 86:e30a1f60f783 219 jfHi = pos + jfWindow;
mjr 87:8d35c74403af 220
mjr 87:8d35c74403af 221 // figure the new position as the centerpoint of the new window
mjr 87:8d35c74403af 222 jfLast = pos = (jfHi + jfLo)/2;
mjr 86:e30a1f60f783 223 return pos;
mjr 86:e30a1f60f783 224 }
mjr 86:e30a1f60f783 225 else if (pos > jfHi)
mjr 86:e30a1f60f783 226 {
mjr 86:e30a1f60f783 227 // the new position is above the current window, so move
mjr 86:e30a1f60f783 228 // the window up such that the new point is at the top of
mjr 86:e30a1f60f783 229 // the window
mjr 86:e30a1f60f783 230 jfHi = pos;
mjr 86:e30a1f60f783 231 jfLo = pos - jfWindow;
mjr 87:8d35c74403af 232
mjr 87:8d35c74403af 233 // figure the new position as the centerpoint of the new window
mjr 87:8d35c74403af 234 jfLast = pos = (jfHi + jfLo)/2;
mjr 86:e30a1f60f783 235 return pos;
mjr 86:e30a1f60f783 236 }
mjr 86:e30a1f60f783 237 else
mjr 86:e30a1f60f783 238 {
mjr 86:e30a1f60f783 239 // the new position is inside the current window, so repeat
mjr 86:e30a1f60f783 240 // the last reading
mjr 86:e30a1f60f783 241 return jfLast;
mjr 86:e30a1f60f783 242 }
mjr 86:e30a1f60f783 243 }
mjr 86:e30a1f60f783 244
mjr 87:8d35c74403af 245 // Process a configuration variable change. 'varno' is the
mjr 87:8d35c74403af 246 // USB protocol variable number being updated; 'cfg' is the
mjr 87:8d35c74403af 247 // updated configuration.
mjr 87:8d35c74403af 248 virtual void onConfigChange(int varno, Config &cfg)
mjr 87:8d35c74403af 249 {
mjr 87:8d35c74403af 250 switch (varno)
mjr 87:8d35c74403af 251 {
mjr 87:8d35c74403af 252 case 19:
mjr 91:ae9be42652bf 253 // Plunger filters - jitter window and reverse orientation.
mjr 87:8d35c74403af 254 setJitterWindow(cfg.plunger.jitterWindow);
mjr 91:ae9be42652bf 255 setReverseOrientation((cfg.plunger.reverseOrientation & 0x01) != 0);
mjr 87:8d35c74403af 256 break;
mjr 87:8d35c74403af 257 }
mjr 87:8d35c74403af 258 }
mjr 87:8d35c74403af 259
mjr 86:e30a1f60f783 260 // Set the jitter filter window size. This is specified in native
mjr 86:e30a1f60f783 261 // sensor units.
mjr 86:e30a1f60f783 262 void setJitterWindow(int w)
mjr 86:e30a1f60f783 263 {
mjr 86:e30a1f60f783 264 // set the new window size
mjr 86:e30a1f60f783 265 jfWindow = w;
mjr 86:e30a1f60f783 266
mjr 86:e30a1f60f783 267 // reset the running window
mjr 86:e30a1f60f783 268 jfHi = jfLo = jfLast;
mjr 86:e30a1f60f783 269 }
mjr 91:ae9be42652bf 270
mjr 91:ae9be42652bf 271 // Set reverse orientation
mjr 91:ae9be42652bf 272 void setReverseOrientation(bool f) { reverseOrientation = f; }
mjr 86:e30a1f60f783 273
mjr 82:4f6209cb5c33 274 protected:
mjr 86:e30a1f60f783 275 // Native scale of the device. This is the scale used for the position
mjr 86:e30a1f60f783 276 // reading in status reports. This lets us report the position in the
mjr 86:e30a1f60f783 277 // same units the sensor itself uses, to avoid any rounding error
mjr 86:e30a1f60f783 278 // converting to an abstract scale.
mjr 86:e30a1f60f783 279 //
mjr 91:ae9be42652bf 280 // The nativeScale value is the number of units in the range of raw
mjr 91:ae9be42652bf 281 // sensor readings returned from readRaw(). Raw readings thus have a
mjr 91:ae9be42652bf 282 // valid range of 0 to nativeScale-1.
mjr 91:ae9be42652bf 283 //
mjr 86:e30a1f60f783 284 // Image edge detection sensors use the pixel size of the image, since
mjr 86:e30a1f60f783 285 // the position is determined by the pixel position of the shadow in
mjr 86:e30a1f60f783 286 // the image. Quadrature sensors and other sensors that report the
mjr 86:e30a1f60f783 287 // distance in terms of physical distance units should use the number
mjr 86:e30a1f60f783 288 // of quanta in the approximate total plunger travel distance of 3".
mjr 86:e30a1f60f783 289 // For example, the VL6180X uses millimeter quanta, so can report
mjr 86:e30a1f60f783 290 // about 77 quanta over 3"; a quadrature sensor that reports at 1/300"
mjr 86:e30a1f60f783 291 // intervals has about 900 quanta over 3". Absolute encoders (e.g.,
mjr 86:e30a1f60f783 292 // bar code sensors) should use the bar code range.
mjr 86:e30a1f60f783 293 //
mjr 86:e30a1f60f783 294 // Sensors that are inherently analog (e.g., potentiometers, analog
mjr 86:e30a1f60f783 295 // distance sensors) can quantize on any arbitrary scale. In most cases,
mjr 86:e30a1f60f783 296 // it's best to use the same 0..65535 scale used for the regular plunger
mjr 86:e30a1f60f783 297 // reports.
mjr 86:e30a1f60f783 298 uint16_t nativeScale;
mjr 86:e30a1f60f783 299
mjr 86:e30a1f60f783 300 // Scaling factor to convert native readings to abstract units on the
mjr 86:e30a1f60f783 301 // 0x0000..0xFFFF scale used in the higher level sensor-independent
mjr 86:e30a1f60f783 302 // code. Multiply a raw sensor position reading by this value to
mjr 86:e30a1f60f783 303 // get the equivalent value on the abstract scale. This is expressed
mjr 86:e30a1f60f783 304 // as a fixed-point real number with a scale of 65536: calculate it as
mjr 86:e30a1f60f783 305 //
mjr 86:e30a1f60f783 306 // (65535U*65536U) / (nativeScale - 1);
mjr 86:e30a1f60f783 307 uint32_t scalingFactor;
mjr 86:e30a1f60f783 308
mjr 86:e30a1f60f783 309 // Jitter filtering
mjr 86:e30a1f60f783 310 int jfWindow; // window size, in native sensor units
mjr 86:e30a1f60f783 311 int jfLo, jfHi; // bounds of current window
mjr 86:e30a1f60f783 312 int jfLast; // last filtered reading
mjr 91:ae9be42652bf 313
mjr 91:ae9be42652bf 314 // Reverse the raw reading orientation. If set, raw readings will be
mjr 91:ae9be42652bf 315 // switched to the opposite orientation. This allows flipping the sensor
mjr 91:ae9be42652bf 316 // orientation virtually to correct for installing the physical device
mjr 91:ae9be42652bf 317 // backwards.
mjr 91:ae9be42652bf 318 bool reverseOrientation;
mjr 82:4f6209cb5c33 319 };
mjr 82:4f6209cb5c33 320
mjr 87:8d35c74403af 321
mjr 87:8d35c74403af 322 // --------------------------------------------------------------------------
mjr 87:8d35c74403af 323 //
mjr 87:8d35c74403af 324 // Generic image sensor interface for image-based plungers
mjr 87:8d35c74403af 325 //
mjr 87:8d35c74403af 326 class PlungerSensorImageInterface
mjr 87:8d35c74403af 327 {
mjr 87:8d35c74403af 328 public:
mjr 87:8d35c74403af 329 PlungerSensorImageInterface(int npix)
mjr 87:8d35c74403af 330 {
mjr 87:8d35c74403af 331 native_npix = npix;
mjr 87:8d35c74403af 332 }
mjr 87:8d35c74403af 333
mjr 87:8d35c74403af 334 // initialize the sensor
mjr 87:8d35c74403af 335 virtual void init() = 0;
mjr 87:8d35c74403af 336
mjr 87:8d35c74403af 337 // is the sensor ready?
mjr 87:8d35c74403af 338 virtual bool ready() = 0;
mjr 87:8d35c74403af 339
mjr 87:8d35c74403af 340 // is a DMA transfer in progress?
mjr 87:8d35c74403af 341 virtual bool dmaBusy() = 0;
mjr 87:8d35c74403af 342
mjr 87:8d35c74403af 343 // read the image
mjr 87:8d35c74403af 344 virtual void readPix(uint8_t* &pix, uint32_t &t, int axcTime) = 0;
mjr 87:8d35c74403af 345
mjr 87:8d35c74403af 346 // Get an image for a pixel status report. 't' is the timestamp of
mjr 87:8d35c74403af 347 // the image. 'extraTime' is extra exposure time for the image, in
mjr 87:8d35c74403af 348 // 0.1ms increments.
mjr 87:8d35c74403af 349 virtual void getStatusReportPixels(
mjr 87:8d35c74403af 350 uint8_t* &pix, uint32_t &t, int axcTime, int extraTime) = 0;
mjr 87:8d35c74403af 351
mjr 87:8d35c74403af 352 // Reset the sensor after a status report. Status reports take a long
mjr 87:8d35c74403af 353 // time to send, so sensors that use continuous integration cycling may
mjr 87:8d35c74403af 354 // need to reset after a status report so that they aren't overexposed
mjr 87:8d35c74403af 355 // by the long delay of sending the status report.
mjr 87:8d35c74403af 356 virtual void resetAfterStatusReport(int axcTime) = 0;
mjr 87:8d35c74403af 357
mjr 87:8d35c74403af 358 // get the average sensor pixel scan time (the time it takes on average
mjr 87:8d35c74403af 359 // to read one image frame from the sensor)
mjr 87:8d35c74403af 360 virtual uint32_t getAvgScanTime() = 0;
mjr 87:8d35c74403af 361
mjr 87:8d35c74403af 362 protected:
mjr 87:8d35c74403af 363 // number of pixels on sensor
mjr 87:8d35c74403af 364 int native_npix;
mjr 87:8d35c74403af 365 };
mjr 87:8d35c74403af 366
mjr 87:8d35c74403af 367
mjr 87:8d35c74403af 368 // ----------------------------------------------------------------------------
mjr 87:8d35c74403af 369 //
mjr 87:8d35c74403af 370 // Plunger base class for image-based sensors
mjr 87:8d35c74403af 371 //
mjr 87:8d35c74403af 372 template<class ProcessResult>
mjr 87:8d35c74403af 373 class PlungerSensorImage: public PlungerSensor
mjr 87:8d35c74403af 374 {
mjr 87:8d35c74403af 375 public:
mjr 87:8d35c74403af 376 PlungerSensorImage(PlungerSensorImageInterface &sensor, int npix, int nativeScale)
mjr 87:8d35c74403af 377 : PlungerSensor(nativeScale), sensor(sensor)
mjr 87:8d35c74403af 378 {
mjr 87:8d35c74403af 379 axcTime = 0;
mjr 87:8d35c74403af 380 native_npix = npix;
mjr 87:8d35c74403af 381 }
mjr 87:8d35c74403af 382
mjr 87:8d35c74403af 383 // initialize the sensor
mjr 87:8d35c74403af 384 virtual void init() { sensor.init(); }
mjr 87:8d35c74403af 385
mjr 87:8d35c74403af 386 // is the sensor ready?
mjr 87:8d35c74403af 387 virtual bool ready() { return sensor.ready(); }
mjr 87:8d35c74403af 388
mjr 87:8d35c74403af 389 // is a DMA transfer in progress?
mjr 87:8d35c74403af 390 virtual bool dmaBusy() { return sensor.dmaBusy(); }
mjr 87:8d35c74403af 391
mjr 87:8d35c74403af 392 // get the pixel transfer time
mjr 87:8d35c74403af 393 virtual uint32_t getAvgScanTime() { return sensor.getAvgScanTime(); }
mjr 87:8d35c74403af 394
mjr 87:8d35c74403af 395 // read the plunger position
mjr 87:8d35c74403af 396 virtual bool readRaw(PlungerReading &r)
mjr 87:8d35c74403af 397 {
mjr 87:8d35c74403af 398 // read pixels from the sensor
mjr 87:8d35c74403af 399 uint8_t *pix;
mjr 87:8d35c74403af 400 uint32_t tpix;
mjr 87:8d35c74403af 401 sensor.readPix(pix, tpix, axcTime);
mjr 87:8d35c74403af 402
mjr 87:8d35c74403af 403 // process the pixels
mjr 87:8d35c74403af 404 int pixpos;
mjr 87:8d35c74403af 405 ProcessResult res;
mjr 87:8d35c74403af 406 if (process(pix, native_npix, pixpos, res))
mjr 87:8d35c74403af 407 {
mjr 87:8d35c74403af 408 r.pos = pixpos;
mjr 87:8d35c74403af 409 r.t = tpix;
mjr 87:8d35c74403af 410
mjr 87:8d35c74403af 411 // success
mjr 87:8d35c74403af 412 return true;
mjr 87:8d35c74403af 413 }
mjr 87:8d35c74403af 414 else
mjr 87:8d35c74403af 415 {
mjr 87:8d35c74403af 416 // no position found
mjr 87:8d35c74403af 417 return false;
mjr 87:8d35c74403af 418 }
mjr 87:8d35c74403af 419 }
mjr 87:8d35c74403af 420
mjr 87:8d35c74403af 421 // Send a status report to the joystick interface.
mjr 87:8d35c74403af 422 // See plunger.h for details on the arguments.
mjr 87:8d35c74403af 423 virtual void sendStatusReport(USBJoystick &js, uint8_t flags, uint8_t extraTime)
mjr 87:8d35c74403af 424 {
mjr 87:8d35c74403af 425 // get pixels
mjr 87:8d35c74403af 426 uint8_t *pix;
mjr 87:8d35c74403af 427 uint32_t t;
mjr 87:8d35c74403af 428 sensor.getStatusReportPixels(pix, t, axcTime, extraTime);
mjr 87:8d35c74403af 429
mjr 87:8d35c74403af 430 // start a timer to measure the processing time
mjr 87:8d35c74403af 431 Timer pt;
mjr 87:8d35c74403af 432 pt.start();
mjr 87:8d35c74403af 433
mjr 87:8d35c74403af 434 // process the pixels and read the position
mjr 87:8d35c74403af 435 int pos, rawPos;
mjr 87:8d35c74403af 436 int n = native_npix;
mjr 87:8d35c74403af 437 ProcessResult res;
mjr 87:8d35c74403af 438 if (process(pix, n, rawPos, res))
mjr 87:8d35c74403af 439 {
mjr 87:8d35c74403af 440 // success - apply the jitter filter
mjr 87:8d35c74403af 441 pos = jitterFilter(rawPos);
mjr 87:8d35c74403af 442 }
mjr 87:8d35c74403af 443 else
mjr 87:8d35c74403af 444 {
mjr 87:8d35c74403af 445 // report 0xFFFF to indicate that the position wasn't read
mjr 87:8d35c74403af 446 pos = 0xFFFF;
mjr 87:8d35c74403af 447 rawPos = 0xFFFF;
mjr 87:8d35c74403af 448 }
mjr 87:8d35c74403af 449
mjr 87:8d35c74403af 450 // note the processing time
mjr 87:8d35c74403af 451 uint32_t processTime = pt.read_us();
mjr 87:8d35c74403af 452
mjr 87:8d35c74403af 453 // If a low-res scan is desired, reduce to a subset of pixels. Ignore
mjr 87:8d35c74403af 454 // this for smaller sensors (below 512 pixels)
mjr 87:8d35c74403af 455 if ((flags & 0x01) && n >= 512)
mjr 87:8d35c74403af 456 {
mjr 87:8d35c74403af 457 // figure how many sensor pixels we combine into each low-res pixel
mjr 87:8d35c74403af 458 const int group = 8;
mjr 87:8d35c74403af 459 int lowResPix = n / group;
mjr 87:8d35c74403af 460
mjr 87:8d35c74403af 461 // combine the pixels
mjr 87:8d35c74403af 462 int src, dst;
mjr 87:8d35c74403af 463 for (src = dst = 0 ; dst < lowResPix ; ++dst)
mjr 87:8d35c74403af 464 {
mjr 87:8d35c74403af 465 // average this block of pixels
mjr 87:8d35c74403af 466 int a = 0;
mjr 87:8d35c74403af 467 for (int j = 0 ; j < group ; ++j)
mjr 87:8d35c74403af 468 a += pix[src++];
mjr 87:8d35c74403af 469
mjr 87:8d35c74403af 470 // we have the sum, so get the average
mjr 87:8d35c74403af 471 a /= group;
mjr 87:8d35c74403af 472
mjr 87:8d35c74403af 473 // store the down-res'd pixel in the array
mjr 87:8d35c74403af 474 pix[dst] = uint8_t(a);
mjr 87:8d35c74403af 475 }
mjr 87:8d35c74403af 476
mjr 87:8d35c74403af 477 // update the pixel count to the reduced array size
mjr 87:8d35c74403af 478 n = lowResPix;
mjr 87:8d35c74403af 479 }
mjr 87:8d35c74403af 480
mjr 87:8d35c74403af 481 // figure the report flags
mjr 87:8d35c74403af 482 int jsflags = 0;
mjr 87:8d35c74403af 483
mjr 87:8d35c74403af 484 // add flags for the detected orientation: 0x01 for normal orientation,
mjr 87:8d35c74403af 485 // 0x02 for reversed orientation; no flags if orientation is unknown
mjr 87:8d35c74403af 486 int dir = getOrientation();
mjr 87:8d35c74403af 487 if (dir == 1)
mjr 87:8d35c74403af 488 jsflags |= 0x01;
mjr 87:8d35c74403af 489 else if (dir == -1)
mjr 87:8d35c74403af 490 jsflags |= 0x02;
mjr 87:8d35c74403af 491
mjr 87:8d35c74403af 492 // send the sensor status report headers
mjr 87:8d35c74403af 493 js.sendPlungerStatus(n, pos, jsflags, sensor.getAvgScanTime(), processTime);
mjr 87:8d35c74403af 494 js.sendPlungerStatus2(nativeScale, jfLo, jfHi, rawPos, axcTime);
mjr 87:8d35c74403af 495
mjr 87:8d35c74403af 496 // send any extra status headers for subclasses
mjr 87:8d35c74403af 497 extraStatusHeaders(js, res);
mjr 87:8d35c74403af 498
mjr 87:8d35c74403af 499 // If we're not in calibration mode, send the pixels
mjr 87:8d35c74403af 500 extern bool plungerCalMode;
mjr 87:8d35c74403af 501 if (!plungerCalMode)
mjr 87:8d35c74403af 502 {
mjr 87:8d35c74403af 503 // send the pixels in report-sized chunks until we get them all
mjr 87:8d35c74403af 504 int idx = 0;
mjr 87:8d35c74403af 505 while (idx < n)
mjr 87:8d35c74403af 506 js.sendPlungerPix(idx, n, pix);
mjr 87:8d35c74403af 507 }
mjr 87:8d35c74403af 508
mjr 87:8d35c74403af 509 // reset the sensor, if necessary
mjr 87:8d35c74403af 510 sensor.resetAfterStatusReport(axcTime);
mjr 87:8d35c74403af 511 }
mjr 87:8d35c74403af 512
mjr 87:8d35c74403af 513 protected:
mjr 87:8d35c74403af 514 // process an image to read the plunger position
mjr 87:8d35c74403af 515 virtual bool process(const uint8_t *pix, int npix, int &rawPos, ProcessResult &res) = 0;
mjr 87:8d35c74403af 516
mjr 87:8d35c74403af 517 // send extra status headers, following the standard headers (types 0 and 1)
mjr 87:8d35c74403af 518 virtual void extraStatusHeaders(USBJoystick &js, ProcessResult &res) { }
mjr 87:8d35c74403af 519
mjr 87:8d35c74403af 520 // get the detected orientation
mjr 87:8d35c74403af 521 virtual int getOrientation() const { return 0; }
mjr 87:8d35c74403af 522
mjr 87:8d35c74403af 523 // underlying hardware sensor interface
mjr 87:8d35c74403af 524 PlungerSensorImageInterface &sensor;
mjr 87:8d35c74403af 525
mjr 87:8d35c74403af 526 // number of pixels
mjr 87:8d35c74403af 527 int native_npix;
mjr 87:8d35c74403af 528
mjr 87:8d35c74403af 529 // auto-exposure time
mjr 87:8d35c74403af 530 uint32_t axcTime;
mjr 87:8d35c74403af 531 };
mjr 87:8d35c74403af 532
mjr 87:8d35c74403af 533
mjr 82:4f6209cb5c33 534 #endif /* PLUNGER_H */