Arnaud VALLEY
/
Pinscape_Controller_V2_arnoz
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: mbed FastIO FastPWM USBDevice
Revision 87:8d35c74403af, committed 2017-05-09
- Comitter:
- mjr
- Date:
- Tue May 09 05:48:37 2017 +0000
- Parent:
- 86:e30a1f60f783
- Child:
- 88:98bce687e6c0
- Commit message:
- AEDR-8300, VL6180X, TLC59116; new plunger firing detection
Changed in this revision
--- a/BitBangI2C/BitBangI2C.cpp Fri Apr 21 18:50:37 2017 +0000
+++ b/BitBangI2C/BitBangI2C.cpp Tue May 09 05:48:37 2017 +0000
@@ -16,7 +16,7 @@
// dprintf() = general debug diagnostics (printed only in case 2)
// eprintf() = error diagnostics (printed in case 1 and above)
//
-#define BBI2C_DEBUG 1
+#define BBI2C_DEBUG 0
#if BBI2C_DEBUG
# define eprintf(...) printf(__VA_ARGS__)
# if BBI2C_DEBUG >= 2
@@ -46,11 +46,14 @@
//
// Bit-bang I2C implementation
//
-BitBangI2C::BitBangI2C(PinName sda, PinName scl) :
- sclPin(scl), sdaPin(sda)
+BitBangI2C::BitBangI2C(PinName sda, PinName scl, bool internalPullup) :
+ sdaPin(sda, internalPullup), sclPin(scl, internalPullup)
{
// set the default frequency to 100kHz
frequency(100000);
+
+ // we're initially in a stop
+ inStop = true;
}
void BitBangI2C::frequency(uint32_t freq)
@@ -62,72 +65,101 @@
if (freq <= 100000)
{
// standard mode I2C bus - up to 100kHz
+
+ // nanosecond parameters
tLow = calcHiResWaitTime(4700);
tHigh = calcHiResWaitTime(4000);
- tBuf = calcHiResWaitTime(4700);
tHdSta = calcHiResWaitTime(4000);
tSuSta = calcHiResWaitTime(4700);
tSuSto = calcHiResWaitTime(4000);
tAck = calcHiResWaitTime(300);
- tData = calcHiResWaitTime(300);
tSuDat = calcHiResWaitTime(250);
+ tBuf = calcHiResWaitTime(4700);
}
else if (freq <= 400000)
{
// fast mode I2C - up to 400kHz
+
+ // nanosecond parameters
tLow = calcHiResWaitTime(1300);
tHigh = calcHiResWaitTime(600);
- tBuf = calcHiResWaitTime(1300);
tHdSta = calcHiResWaitTime(600);
tSuSta = calcHiResWaitTime(600);
tSuSto = calcHiResWaitTime(600);
tAck = calcHiResWaitTime(100);
- tData = calcHiResWaitTime(100);
tSuDat = calcHiResWaitTime(100);
+ tBuf = calcHiResWaitTime(1300);
}
else
{
// fast mode plus - up to 1MHz
+
+ // nanosecond parameters
tLow = calcHiResWaitTime(500);
tHigh = calcHiResWaitTime(260);
- tBuf = calcHiResWaitTime(500);
tHdSta = calcHiResWaitTime(260);
tSuSta = calcHiResWaitTime(260);
tSuSto = calcHiResWaitTime(260);
tAck = calcHiResWaitTime(50);
- tData = calcHiResWaitTime(50);
tSuDat = calcHiResWaitTime(50);
+ tBuf = calcHiResWaitTime(500);
}
}
void BitBangI2C::start()
{
- // take clock and data high
- sclHi();
- sdaHi();
- hiResWait(tBuf);
+ // check to see if we're starting after a stop, or if this is a
+ // repeated start
+ if (inStop)
+ {
+ // in a stop - make sure we waited for the minimum hold time
+ hiResWait(tBuf);
+ }
+ else
+ {
+ // repeated start - take data high
+ sdaHi();
+ hiResWait(tSuDat);
+
+ // take clock high
+ sclHi();
+
+ // wait for the minimum setup period
+ hiResWait(tSuSta);
+ }
// take data low
sdaLo();
- hiResWait(tHdSta);
- // take clock low
+ // wait for the setup period and take clock low
+ hiResWait(tHdSta);
sclLo();
- hiResWait(tLow);
+
+ // wait for the low period
+ hiResWait(tLow);
+
+ // no longer in a stop
+ inStop = false;
}
void BitBangI2C::stop()
{
- // take SDA low
- sdaLo();
+ // if we're not in a stop, enter one
+ if (!inStop)
+ {
+ // take SDA low
+ sdaLo();
- // take SCL high
- sclHi();
- hiResWait(tSuSto);
-
- // take SDA high
- sdaHi();
- hiResWait(tBuf);
+ // take SCL high
+ sclHi();
+ hiResWait(tSuSto);
+
+ // take SDA high
+ sdaHi();
+
+ // we're in a stop
+ inStop = true;
+ }
}
bool BitBangI2C::wait(uint32_t timeout_us)
@@ -233,13 +265,25 @@
// write the bits, most significant first
for (int i = 0 ; i < 8 ; ++i, data <<= 1)
writeBit(data & 0x80);
-
- // read and return the ACK bit
- return readBit();
+
+ // release SDA so the device can control it
+ sdaHi();
+
+ // read the ACK bit
+ int ack = readBit();
+
+ // take SDA low again
+ sdaLo();
+
+ // return success if ACK was 0
+ return ack;
}
int BitBangI2C::read(bool ack)
{
+ // take SDA high before reading
+ sdaHi();
+
// read 8 bits, most significant first
uint8_t data = 0;
for (int i = 0 ; i < 8 ; ++i)
@@ -248,6 +292,9 @@
// switch to output mode and send the ACK bit
writeBit(!ack);
+ // release SDA
+ sdaHi();
+
// return the data byte we read
return data;
}
@@ -260,27 +307,29 @@
// Wait (within reason) for it to actually read as high. The device
// can intentionally pull the clock line low to tell us to wait while
// it's working on preparing the data for us.
- Timer t;
- t.start();
- while (sclPin.read() == 0 && t.read_us() < 500000) ;
-
- // if the clock isn't high, we timed out
- if (sclPin.read() == 0)
+ int t = 0;
+ do
{
- eprintf("i2c.readBit, clock stretching timeout\r\n");
- return 0;
+ // if the clock is high, we're ready to go
+ if (sclPin.read())
+ {
+ // wait for the data setup time
+ hiResWait(tSuDat);
+
+ // read the bit
+ bool bit = sdaPin.read();
+
+ // take the clock low again
+ sclLo();
+ hiResWait(tLow);
+
+ // return the bit
+ return bit;
+ }
}
-
- // wait until the clock interval is up
- while (t.read_us() < clkPeriod_us);
-
- // read the bit
- bool bit = sdaPin.read();
-
- // take the clock low again
- sclLo();
- hiResWait(tLow);
-
- // return the bit
- return bit;
+ while (t++ < 100000);
+
+ // we timed out
+ eprintf("i2c.readBit, clock stretching timeout\r\n");
+ return 0;
}
--- a/BitBangI2C/BitBangI2C.h Fri Apr 21 18:50:37 2017 +0000
+++ b/BitBangI2C/BitBangI2C.h Tue May 09 05:48:37 2017 +0000
@@ -34,13 +34,17 @@
// the nominal address from the data sheet left one bit in each call
// to a routine here.
//
-// Electrically, the I2C bus is designed as a a pair of open-collector
-// lines with pull-up resistors. Any device can pull a line low by
-// shorting it to ground, but no one can pull a line high: instead, you
-// *allow* a line to go high by releasing it, which is to say putting
-// your connection to it in a high-Z state. On an MCU, we put a GPIO
-// pin in high-Z state by setting its direction to INPUT mode. So our
-// GPIO write strategy is like this:
+// Electrically, the I2C bus consists of two lines, SDA (data) and SCL
+// (clock). Multiple devices can connect to the bus by connecting to
+// these two lines; the lines are shared among all of the devices. Each
+// line has a pull-up resistor that pulls it to logic '1' voltage. Each
+// device connects with an open-collector circuit that can short the line
+// to ground (logic '0'). This means that any device can assert a 'low'
+// but no one can actually assert a 'high'; the pull-up makes it so that
+// a 'high' occurs when no one is asserting a 'low'. On an MCU, we release
+// a line by putting the GPIO pin in high-Z state, which we can do on the
+// KL25Z by setting its direction to INPUT mode. So our GPIO write strategy
+// is like this:
//
// - take a pin low (0):
// pin.input();
@@ -54,6 +58,12 @@
// the direction to output is enough to assert the low level, since the
// hardware asserts the level that was previously stored in the output
// register whenever the direction is changed from input to output.
+//
+// The KL25Z by default provides a built-in pull-up resistor on each GPIO
+// set to input mode. This can optionally be used as the bus-wide pull-up
+// for each line. Standard practice is to use external pull-up resistors
+// rather than MCU pull-ups, but the internal pull-ups are fine for ad hoc
+// setups where there's only one external device connected to a GPIO pair.
#ifndef _BITBANGI2C_H_
@@ -64,6 +74,27 @@
#include "pinmap.h"
+// For testing purposes: a cover class for the mbed library I2C bridging
+// the minor differences in our interface. This allows switching between
+// BitBangI2C and the mbed library I2C via a macro of the like.
+class MbedI2C: public I2C
+{
+public:
+ MbedI2C(PinName sda, PinName scl, bool internalPullups) : I2C(sda, scl) { }
+
+ int write(int addr, const uint8_t *data, size_t len, bool repeated = false)
+ {
+ return I2C::write(addr, (const char *)data, len, repeated);
+ }
+ int read(int addr, uint8_t *data, size_t len, bool repeated = false)
+ {
+ return I2C::read(addr, (char *)data, len, repeated);
+ }
+
+ void reset() { }
+};
+
+
// DigitalInOut replacmement class for I2C use. I2C uses pins a little
// differently from other use cases. I2C is a bus, where many devices can
// be attached to each line. To allow this shared access, devices can
@@ -81,19 +112,23 @@
class I2CInOut
{
public:
- I2CInOut(PinName pin)
+ I2CInOut(PinName pin, bool internalPullup)
{
// initialize the pin
gpio_t g;
gpio_init(&g, pin);
// get the registers
- unsigned int port = (unsigned int)pin >> PORT_SHIFT;
- FGPIO_Type *r = (FGPIO_Type *)(FPTA_BASE + port*0x40);
- __IO uint32_t *pin_pcr = (__IO uint32_t*)(PORTA_BASE + pin);
+ unsigned int portno = (unsigned int)pin >> PORT_SHIFT;
+ uint32_t pinno = (uint32_t)(pin & 0x7C) >> 2;
+ FGPIO_Type *r = (FGPIO_Type *)(FPTA_BASE + portno*0x40);
+ __IO uint32_t *pin_pcr = &(((PORT_Type *)(PORTA_BASE + 0x1000*portno)))->PCR[pinno];
- // set no-pull-up mode (clear PE bit = Pull Enable)
- *pin_pcr &= ~0x02;
+ // set the desired internal pull-up mode
+ if (internalPullup)
+ *pin_pcr |= 0x02;
+ else
+ *pin_pcr &= ~0x02;
// save the register information we'll need later
this->mask = g.mask;
@@ -148,7 +183,7 @@
{
public:
// create the interface
- BitBangI2C(PinName sda, PinName scl);
+ BitBangI2C(PinName sda, PinName scl, bool internalPullups);
// set the bus frequency in Hz
void frequency(uint32_t freq);
@@ -192,7 +227,7 @@
// clock it
sclPin.hi();
- hiResWait(tData);
+ hiResWait(tHigh);
// drop the clock
sclPin.lo();
@@ -208,9 +243,9 @@
inline void sdaHi() { sdaPin.hi(); }
inline void sdaLo() { sdaPin.lo(); }
- // SCL and SDA pins
+ // SDA and SCL pins
+ I2CInOut sdaPin;
I2CInOut sclPin;
- I2CInOut sdaPin;
// inverse of frequency = clock period in microseconds
uint32_t clkPeriod_us;
@@ -263,13 +298,15 @@
//
int tLow; // SCL low period
int tHigh; // SCL high period
- int tBuf; // bus free time between start and stop conditions
int tHdSta; // hold time for start condition
int tSuSta; // setup time for repeated start condition
int tSuSto; // setup time for stop condition
int tSuDat; // data setup time
int tAck; // ACK time
- int tData; // data valid time
+ int tBuf; // bus free time between start and stop conditions
+
+ // are we in a Stop condition?
+ bool inStop;
};
#endif /* _BITBANGI2C_H_ */
--- a/Plunger/barCodeSensor.h Fri Apr 21 18:50:37 2017 +0000
+++ b/Plunger/barCodeSensor.h Tue May 09 05:48:37 2017 +0000
@@ -5,10 +5,19 @@
// by reading the bar code and decoding it into a position figure.
//
// The bar code has to be encoded in a specific format that we recognize.
-// We use a 10-bit reflected Gray code, optically encoded using a Manchester-
-// type of coding. Each bit is represented as a fixed-width area on the
-// bar, half white and half black. The bit value is encoded in the order
-// of the colors: Black/White is '0', and White/Black is '1'.
+// We use a reflected Gray code, optically encoded in black/white pixel
+// patterns. Each bit is represented by a fixed-width area. Half the
+// pixels in every bit are white, and half are black. A '0' bit is
+// represented by black pixels in the left half and white pixels in the
+// right half, and a '1' bit is white on the left and black on the right.
+// To read a bit, we identify the set of pixels covering the bit's fixed
+// area in the code, then we see if the left or right half is brighter.
+//
+// (This optical encoding scheme is based on Manchester coding, which is
+// normally used in the context of serial protocols, but translates to
+// bar codes straightforwardly. Replace the serial protocol's time
+// dimension with the spatial dimension across the bar, and replace the
+// high/low wire voltage levels with white/black pixels.)
//
// Gray codes are ideal for this type of application. Gray codes are
// defined such that each code point differs in exactly one bit from each
@@ -20,21 +29,73 @@
// the reading will come out as one of points on either side of the true
// position. Finally, motion blur will have the same effect, of creating
// ambiguity in the least significant bits, and thus giving us a reading
-// that's correct to as many bits as we can read with teh blur.
+// that's correct to as many bits as we can make out.
//
-// We use the Manchester-type optical coding because it has good properties
-// for low-contrast images, and doesn't require uniform lighting. Each bit's
-// pixel span contains equal numbers of light and dark pixels, so each bit
-// provides its own local level reference. This means we don't care about
-// lighting uniformity over the whole image, because we don't need a global
-// notion of light and dark, just a local one over a single bit at a time.
+// The half-and-half optical coding also has good properties for our
+// purposes. The fixed-width bit regions require essentially no CPU work
+// to find the bits, which is good because we're using a fairly slow CPU.
+// The half white/half black coding of each pixel makes every pixel
+// self-relative in terms of brightness, so we don't need to figure the
+// black and white thresholds globally for the whole image. That makes
+// the physical device engineering and installation easier because the
+// software can tolerate a fairly wide range of lighting conditions.
//
#ifndef _BARCODESENSOR_H_
#define _BARCODESENSOR_H_
#include "plunger.h"
-#include "tsl14xxSensor.h"
+
+// Gray code to binary mapping for our special coding. This is a custom
+// 7-bit code, minimum run length 6, 110 positions populated. The minimum
+// run length is the minimum number of consecutive code points where each
+// bit must remain fixed. For out optical coding, this defines the smallest
+// "island" size for a black or white bar horizontally. Small features are
+// prone to light scattering that makes them appear gray on the sensor.
+// Larger features are less subject to scatter, making them easier to
+// distinguish by brightness level.
+static const uint8_t grayToBin[] = {
+ 0, 1, 83, 2, 71, 100, 84, 3, 69, 102, 82, 128, 70, 101, 57, 4, // 0-15
+ 35, 50, 36, 37, 86, 87, 85, 128, 34, 103, 21, 104, 128, 128, 20, 5, // 16-31
+ 11, 128, 24, 25, 98, 99, 97, 40, 68, 67, 81, 80, 55, 54, 56, 41, // 32-47
+ 10, 51, 23, 38, 128, 52, 128, 39, 9, 66, 22, 128, 8, 53, 7, 6, // 48-63
+ 47, 14, 60, 128, 72, 15, 59, 16, 46, 91, 93, 92, 45, 128, 58, 17, // 64-79
+ 48, 49, 61, 62, 73, 88, 74, 75, 33, 90, 106, 105, 32, 89, 19, 18, // 80-95
+ 12, 13, 95, 26, 128, 28, 96, 27, 128, 128, 94, 79, 44, 29, 43, 42, // 96-111
+ 128, 64, 128, 63, 110, 128, 109, 76, 128, 65, 107, 78, 31, 30, 108, 77 // 112-127
+};
+
+
+// Auto-exposure counter
+class BarCodeExposureCounter
+{
+public:
+ BarCodeExposureCounter()
+ {
+ nDark = 0;
+ nBright = 0;
+ nZero = 0;
+ nSat = 0;
+ }
+
+ inline void count(int pix)
+ {
+ if (pix <= 2)
+ ++nZero;
+ else if (pix < 12)
+ ++nDark;
+ else if (pix >= 253)
+ ++nSat;
+ else if (pix > 200)
+ ++nBright;
+ }
+
+ int nDark; // dark pixels
+ int nBright; // bright pixels
+ int nZero; // pixels at zero brightness
+ int nSat; // pixels at full saturation
+};
+
// Base class for bar-code sensors
//
@@ -58,13 +119,51 @@
// full bit, including both "half bits" - it's the full white/black or
// black/white pattern area.
+struct BarCodeProcessResult
+{
+ int pixofs;
+ int raw;
+ int mask;
+};
+
template <int nBits, int leftBarWidth, int leftBarMaxOfs, int bitWidth>
-class PlungerSensorBarCode
+class PlungerSensorBarCode: public PlungerSensorImage<BarCodeProcessResult>
{
public:
+ PlungerSensorBarCode(PlungerSensorImageInterface &sensor, int npix)
+ : PlungerSensorImage(sensor, npix, (1 << nBits) - 1)
+ {
+ startOfs = 0;
+ }
+
+ // process a configuration change
+ virtual void onConfigChange(int varno, Config &cfg)
+ {
+ // check for bar-code variables
+ switch (varno)
+ {
+ case 20:
+ // bar code offset
+ startOfs = cfg.plunger.barCode.startPix;
+ break;
+ }
+
+ // do the generic work
+ PlungerSensorImage::onConfigChange(varno, cfg);
+ }
+
+protected:
// process the image
- bool process(const uint8_t *pix, int npix, int &pos)
+ virtual bool process(const uint8_t *pix, int npix, int &pos, BarCodeProcessResult &res)
{
+ // adjust auto-exposure
+ adjustExposure(pix, npix);
+
+ // clear the result descriptor
+ res.pixofs = 0;
+ res.raw = 0;
+ res.mask = 0;
+
#if 0 // $$$
// scan from the left edge until we find the fixed '0' start bit
@@ -147,25 +246,46 @@
}
else
{
- barStart = 4; // $$$ should be configurable via config tool
+ // start at the fixed pixel offset
+ barStart = startOfs;
}
+ // Start with zero in the barcode and success mask. The mask
+ // indicates which bits we were able to read successfully: a
+ // '1' bit in the mask indicates that the corresponding bit
+ // position in 'barcode' was successfully read, a '0' bit means
+ // that the image was too fuzzy to read.
+ int barcode = 0, mask = 0;
+
// Scan the bits
- int barcode = 0;
for (int bit = 0, x0 = barStart; bit < nBits ; ++bit, x0 += bitWidth)
{
- // figure the extent of this bit
- int x1 = x0 + bitWidth / 2;
- int x2 = x0 + bitWidth;
+#if 0
+ // Figure the extent of this bit. The last bit is double
+ // the width of the other bits, to give us a better chance
+ // of making out the small features of the last bit.
+ int w = bitWidth;
+ if (bit == nBits - 1) w *= 2;
+#else
+ // width of the bit
+ const int w = bitWidth;
+#endif
+
+ // figure the bit's internal pixel layout
+ int halfBitWidth = w / 2;
+ int x1 = x0 + halfBitWidth; // midpoint
+ int x2 = x0 + w; // right edge
+
+ // make sure we didn't go out of bounds
if (x1 > npix) x1 = npix;
if (x2 > npix) x2 = npix;
+#if 0
// get the average of the pixels over the bit
int sum = 0;
for (int x = x0 ; x < x2 ; ++x)
sum += pix[x];
- int avg = sum / bitWidth;
-
+ int avg = sum / w;
// Scan the left and right sections. Classify each
// section according to whether the majority of its
// pixels are above or below the local average.
@@ -174,20 +294,56 @@
lsum += (pix[x] < avg ? 0 : 1);
for (int x = x1 + 1 ; x < x2 - 1 ; ++x)
rsum += (pix[x] < avg ? 0 : 1);
+#else
+ // Sum the pixel readings in each half-bit. Ignore
+ // the first and last bit of each section, since these
+ // could be contaminated with scattered light from the
+ // adjacent half-bit. On the right half, hew to the
+ // right side if the overall pixel width is odd.
+ int lsum = 0, rsum = 0;
+ for (int x = x0 + 1 ; x < x1 - 1 ; ++x)
+ lsum += pix[x];
+ for (int x = x2 - halfBitWidth + 1 ; x < x2 - 1 ; ++x)
+ rsum += pix[x];
+#endif
- // if we don't have a winner, fail
- if (lsum == rsum)
- return false;
+ // shift a zero bit into the code and success mask
+ barcode <<= 1;
+ mask <<= 1;
- // black/white = 0, white/black = 1
- barcode = (barcode << 1) | (lsum < rsum ? 0 : 1);
+ // Brightness difference required per pixel. Higher values
+ // require greater contrast to make a reading, which reduces
+ // spurious readings at the cost of reducing the overall
+ // success rate. The right level depends on the quality of
+ // the optical system. Setting this to zero makes us maximally
+ // tolerant of low-contrast images, allowing for the simplest
+ // optical system. Our simple optical system suffers from
+ // poor focus, which in turn causes poor contrast in small
+ // features.
+ const int minDelta = 2;
+
+ // see if we could tell the difference in brightness
+ int delta = lsum - rsum;
+ if (delta < 0) delta = -delta;
+ if (delta > minDelta * w/2)
+ {
+ // got it - black/white = 0, white/black = 1
+ if (lsum > rsum) barcode |= 1;
+ mask |= 1;
+ }
}
// decode the Gray code value to binary
- pos = grayToBin(barcode);
+ pos = grayToBin[barcode];
- // success
- return true;
+ // set the results descriptor structure
+ res.pixofs = barStart;
+ res.raw = barcode;
+ res.mask = mask;
+
+ // return success if we decoded all bits, and the Gray-to-binary
+ // mapping was populated
+ return pos != (1 << nBits) && mask == ((1 << nBits) - 1);
#endif
}
@@ -255,83 +411,17 @@
}
}
- // convert a reflected Gray code value (up to 16 bits) to binary
- int grayToBin(int grayval)
- {
- int temp = grayval ^ (grayval >> 8);
- temp ^= (temp >> 4);
- temp ^= (temp >> 2);
- temp ^= (temp >> 1);
- return temp;
- }
-};
-
-// Auto-exposure counter
-class BarCodeExposureCounter
-{
-public:
- BarCodeExposureCounter()
- {
- nDark = 0;
- nBright = 0;
- nZero = 0;
- nSat = 0;
- }
-
- inline void count(int pix)
- {
- if (pix <= 2)
- ++nZero;
- else if (pix < 12)
- ++nDark;
- else if (pix >= 253)
- ++nSat;
- else if (pix > 200)
- ++nBright;
- }
-
- int nDark; // dark pixels
- int nBright; // bright pixels
- int nZero; // pixels at zero brightness
- int nSat; // pixels at full saturation
-};
-
-// PlungerSensor interface implementation for bar code readers.
-//
-// Bar code readers are image sensors, so we have a pixel size for
-// the sensor. However, this isn't the scale for the readings. The
-// scale for the readings is determined by the number of bits in the
-// bar code, since an n-bit bar code can encode 2^n distinct positions.
-//
-template <int nBits, int leftBarWidth, int leftBarMaxOfs, int bitWidth>
-class PlungerSensorBarCodeTSL14xx: public PlungerSensorTSL14xxSmall,
- PlungerSensorBarCode<nBits, leftBarWidth, leftBarMaxOfs, bitWidth>
-{
-public:
- PlungerSensorBarCodeTSL14xx(int nativePix, PinName si, PinName clock, PinName ao)
- : PlungerSensorTSL14xxSmall(nativePix, (1 << nBits) - 1, si, clock, ao)
- {
- // the native scale is the number of positions we can
- // encode in the bar code
- nativeScale = 1023;
- }
-
-protected:
-
- // process the image through the bar code reader
- virtual bool process(const uint8_t *pix, int npix, int &pos)
- {
- // adjust the exposure
- adjustExposure(pix, npix);
-
- // do the standard bar code processing
- return PlungerSensorBarCode<nBits, leftBarWidth, leftBarMaxOfs, bitWidth>
- ::process(pix, npix, pos);
- }
-
// bar code sensor orientation is fixed
virtual int getOrientation() const { return 1; }
+ // send extra status report headers
+ virtual void extraStatusHeaders(USBJoystick &js, BarCodeProcessResult &res)
+ {
+ // Send the bar code status report. We use coding type 1 (Gray code,
+ // Manchester pixel coding).
+ js.sendPlungerStatusBarcode(nBits, 1, res.pixofs, bitWidth, res.raw, res.mask);
+ }
+
// adjust the exposure
void adjustExposure(const uint8_t *pix, int npix)
{
@@ -342,23 +432,24 @@
// pixels has to look: the bit area will be 50% black and 50%
// white, and the margins will be all white. For maximum
// contrast, target an exposure level where the black pixels
- // are all below the middle brightness level and the white
+ // are all below a certain brightness level and the white
// pixels are all above. Start by figuring the number of
// pixels above and below.
- int nDark = 0;
+ const int medianTarget = 160;
+ int nBelow = 0;
for (int i = 0 ; i < npix ; ++i)
{
- if (pix[i] < 200)
- ++nDark;
+ if (pix[i] < medianTarget)
+ ++nBelow;
}
- // Figure the percentage of black pixels: the left bar is
+ // Figure the desired number of black pixels: the left bar is
// all black pixels, and 50% of each bit is black pixels.
- int targetDark = leftBarWidth + (nBits * bitWidth)/2;
+ int targetBelow = leftBarWidth + (nBits * bitWidth)/2;
// Increase exposure time if too many pixels are below the
// halfway point; decrease it if too many pixels are above.
- int d = nDark - targetDark;
+ int d = nBelow - targetBelow;
if (d > 5 || d < -5)
{
axcTime += d;
@@ -475,20 +566,21 @@
if (axcTime > 2500)
axcTime = 2500;
}
-};
-// TSL1401CL - 128-bit image sensor, used as a bar code reader
-class PlungerSensorTSL1401CL: public PlungerSensorBarCodeTSL14xx<
- 10, // number of bits in code
- 0, // left delimiter bar width in pixels (0 for none)
- 24, // maximum left margin width in pixels
- 12> // pixel width of each bit
-{
-public:
- PlungerSensorTSL1401CL(PinName si, PinName clock, PinName a0)
- : PlungerSensorBarCodeTSL14xx(128, si, clock, a0)
+#if 0
+ // convert a reflected Gray code value (up to 16 bits) to binary
+ static inline int grayToBin(int grayval)
{
+ int temp = grayval ^ (grayval >> 8);
+ temp ^= (temp >> 4);
+ temp ^= (temp >> 2);
+ temp ^= (temp >> 1);
+ return temp;
}
+#endif
+
+ // bar code starting pixel offset
+ int startOfs;
};
#endif
--- a/Plunger/distanceSensor.h Fri Apr 21 18:50:37 2017 +0000
+++ b/Plunger/distanceSensor.h Tue May 09 05:48:37 2017 +0000
@@ -43,8 +43,8 @@
public:
PlungerSensorDistance(int nativeScale) : PlungerSensor(nativeScale)
{
- // start the sample timer
- t.start();
+ totalTime = 0;
+ nRuns = 0;
}
// get the average scan time
@@ -58,11 +58,7 @@
nRuns += 1;
}
- // sample timer
- Timer t;
-
// scan time statistics
- uint32_t tStart; // time (on this->t) of start of current scan
uint64_t totalTime; // total time consumed by all reads so far
uint32_t nRuns; // number of runs so far
};
@@ -73,66 +69,79 @@
// sensor units are millimeters. A physical plunger has about 3" of
// total travel, but leave a little extra padding for measurement
// inaccuracies and other unusual situations, so'll use an actual
-// native scale of 5" = 127mm.
+// native scale of 150mm.
class PlungerSensorVL6180X: public PlungerSensorDistance
{
public:
PlungerSensorVL6180X(PinName sda, PinName scl, PinName gpio0)
- : PlungerSensorDistance(127),
- sensor(sda, scl, I2C_ADDRESS, gpio0)
+ : PlungerSensorDistance(150),
+ sensor(sda, scl, I2C_ADDRESS, gpio0, true)
{
}
- static const int I2C_ADDRESS = 0x28;
+ // fixed I2C bus address for the VL6180X
+ static const int I2C_ADDRESS = 0x29;
virtual void init()
{
- // reboot and initialize the sensor
+ // initialize the sensor and set the default configuration
sensor.init();
-
- // set the default configuration
sensor.setDefaults();
- // start the first reading
- tStart = t.read_us();
+ // start a reading
sensor.startRangeReading();
}
virtual bool ready()
{
+ // make sure a reading has been initiated
+ sensor.startRangeReading();
+
+ // check if a reading is ready
return sensor.rangeReady();
}
virtual bool readRaw(PlungerReading &r)
{
- // get the range reading
- uint8_t d;
- int err = sensor.getRange(d, 25000);
-
- // start a new reading
- sensor.startRangeReading();
- tStart = t.read_us();
-
- // use the current timestamp
- r.t = t.read_us();
+ // if we have a new reading ready, collect it
+ if (sensor.rangeReady())
+ {
+ // Get the range reading. Note that we already know that the
+ // sensor has a reading ready, so it shouldn't be possible to
+ // time out on the read. (The sensor could have timed out on
+ // convergence, but if it did, that's in the past already so
+ // it's not something we have to wait for now.)
+ uint8_t d;
+ uint32_t t, dt;
+ lastErr = sensor.getRange(d, t, dt, 100);
+
+ // if we got a reading, update the last reading
+ if (lastErr == 0)
+ {
+ // save the new reading
+ last.pos = d;
+ last.t = t;
+
+ // collect scan time statistics
+ collectScanTimeStats(dt);
+ }
+
+ // start a new reading
+ sensor.startRangeReading();
+ }
- // The sensor measures distance from the front of the cabinet
- // (in our standard setup). For reporting purposes, we want
- // the position reading to increase as the plunger is retracted,
- // so we want to reverse the scale.
- r.pos = nativeScale - d;
-
- // collect scan time statistics
- if (err == 0)
- collectScanTimeStats(uint32_t(r.t - tStart));
-
- // return the status ('err' is zero on success)
- return err == 0;
+ // return the most recent reading
+ r = last;
+ return lastErr == 0;
}
protected:
// underlying sensor interface
VL6180X sensor;
+
+ // last reading and error status
+ PlungerReading last;
+ int lastErr;
};
--- a/Plunger/edgeSensor.h Fri Apr 21 18:50:37 2017 +0000
+++ b/Plunger/edgeSensor.h Tue May 09 05:48:37 2017 +0000
@@ -18,7 +18,6 @@
#define _EDGESENSOR_H_
#include "plunger.h"
-#include "tsl14xxSensor.h"
// Scan method - select a method listed below. Method 2 (find the point
// with maximum brightness slop) seems to work the best so far.
@@ -101,12 +100,15 @@
// This is a generic base class for image-based sensors where we detect
// the plunger position by finding the edge of the shadow it casts on
// the detector.
-class PlungerSensorEdgePos
+//
+// Edge sensors use the image pixel span as the native position scale,
+// since a position reading is the pixel offset of the shadow edge.
+class PlungerSensorEdgePos: public PlungerSensorImage<int>
{
public:
- PlungerSensorEdgePos(int npix)
+ PlungerSensorEdgePos(PlungerSensorImageInterface &sensor, int npix)
+ : PlungerSensorImage<int>(sensor, npix, npix - 1)
{
- native_npix = npix;
}
// Process an image - scan for the shadow edge to determine the plunger
@@ -121,7 +123,7 @@
#if SCAN_METHOD == 0
// Scan method 0: one-way scan; original method used in v1 firmware.
- bool process(const uint8_t *pix, int n, int &pos)
+ bool process(const uint8_t *pix, int n, int &pos, int& /*processResult*/)
{
// Get the levels at each end
int a = (int(pix[0]) + pix[1] + pix[2] + pix[3] + pix[4])/5;
@@ -241,7 +243,7 @@
#if SCAN_METHOD == 1
// Scan method 1: meet in the middle.
- bool process(const uint8_t *pix, int n, int &pos)
+ bool process(const uint8_t *pix, int n, int &pos, int& /*processResult*/)
{
// Get the levels at each end
int a = (int(pix[0]) + pix[1] + pix[2] + pix[3] + pix[4])/5;
@@ -361,7 +363,7 @@
#if SCAN_METHOD == 2
// Scan method 2: scan for steepest brightness slope.
- bool process(const uint8_t *pix, int n, int &pos)
+ virtual bool process(const uint8_t *pix, int n, int &pos, int& /*processResult*/)
{
// Get the levels at each end by averaging across several pixels.
// Compute just the sums: don't bother dividing by the count, since
@@ -419,7 +421,7 @@
#if SCAN_METHOD == 3
// Scan method 0: one-way scan; original method used in v1 firmware.
- bool process(const uint8_t *pix, int n, int &pos)
+ bool process(const uint8_t *pix, int n, int &pos, int& /*processResult*/)
{
// Get the levels at each end
int a = (int(pix[0]) + pix[1] + pix[2] + pix[3] + pix[4])/5;
@@ -497,9 +499,6 @@
virtual int getOrientation() const { return dir; }
int dir;
- // number of pixels
- int native_npix;
-
// History of midpoint brightness levels for the last few successful
// scans. This is a circular buffer that we write on each scan where
// we successfully detect a shadow edge. (It's circular, so we
@@ -531,62 +530,4 @@
};
-// -------------------------------------------------------------------------
-//
-// Edge position plunger sensor for TSL14xx-based sensors. An edge
-// detection setup requires one of the large sensors, 1410R or 1412S,
-// since we need the sensor to cover the whole extent of the physical
-// plunger's travel, which is about 3".
-//
-// The native scale for image edge detectors is sensor pixels, since
-// we read the plunger position as the pixel location of the shadow
-// edge on the image.
-//
-class PlungerSensorEdgePosTSL14xx: public PlungerSensorTSL14xxLarge, public PlungerSensorEdgePos
-{
-public:
- PlungerSensorEdgePosTSL14xx(int nativePix, PinName si, PinName clock, PinName ao)
- : PlungerSensorTSL14xxLarge(nativePix, nativePix - 1, si, clock, ao),
- PlungerSensorEdgePos(nativePix)
- {
- // we don't know the direction yet
- dir = 0;
-
- // set the midpoint history arbitrarily to the absolute halfway point
- memset(midpt, 127, sizeof(midpt));
- midptIdx = 0;
-
- // the native reporting scale is the pixel size of the sensor, since
- // the position is figured as the shadow location in the image
- nativeScale = nativePix;
- }
-
-protected:
- // process the image through the edge detector
- virtual bool process(const uint8_t *pix, int npix, int &pixpos)
- {
- return PlungerSensorEdgePos::process(pix, npix, pixpos);
- }
-};
-
-// TSL1410R sensor
-class PlungerSensorTSL1410R: public PlungerSensorEdgePosTSL14xx
-{
-public:
- PlungerSensorTSL1410R(PinName si, PinName clock, PinName ao)
- : PlungerSensorEdgePosTSL14xx(1280, si, clock, ao)
- {
- }
-};
-
-// TSL1412R
-class PlungerSensorTSL1412R: public PlungerSensorEdgePosTSL14xx
-{
-public:
- PlungerSensorTSL1412R(PinName si, PinName clock, PinName ao)
- : PlungerSensorEdgePosTSL14xx(1536, si, clock, ao)
- {
- }
-};
-
#endif /* _EDGESENSOR_H_ */
--- a/Plunger/plunger.h Fri Apr 21 18:50:37 2017 +0000
+++ b/Plunger/plunger.h Tue May 09 05:48:37 2017 +0000
@@ -13,6 +13,8 @@
#ifndef PLUNGER_H
#define PLUNGER_H
+#include "config.h"
+
// Plunger reading with timestamp
struct PlungerReading
{
@@ -73,6 +75,9 @@
// working on the current reading's data transfer.
virtual bool ready() { return true; }
+ // Is a plunger DMA operation in progress?
+ virtual bool dmaBusy() { return false; }
+
// Read the sensor position, if possible. Returns true on success,
// false if it wasn't possible to take a reading. On success, fills
// in 'r' with the current reading and timestamp and returns true.
@@ -103,7 +108,7 @@
if (readRaw(r))
{
// process it through the jitter filter
- //$$$ r.pos = jitterFilter(r.pos);
+ r.pos = jitterFilter(r.pos);
// adjust to the abstract scale via the scaling factor
r.pos = uint16_t(uint32_t((scalingFactor * r.pos) + 32768) >> 16);
@@ -195,7 +200,9 @@
// of the window
jfLo = pos;
jfHi = pos + jfWindow;
- jfLast = pos;
+
+ // figure the new position as the centerpoint of the new window
+ jfLast = pos = (jfHi + jfLo)/2;
return pos;
}
else if (pos > jfHi)
@@ -205,7 +212,9 @@
// the window
jfHi = pos;
jfLo = pos - jfWindow;
- jfLast = pos;
+
+ // figure the new position as the centerpoint of the new window
+ jfLast = pos = (jfHi + jfLo)/2;
return pos;
}
else
@@ -216,6 +225,20 @@
}
}
+ // Process a configuration variable change. 'varno' is the
+ // USB protocol variable number being updated; 'cfg' is the
+ // updated configuration.
+ virtual void onConfigChange(int varno, Config &cfg)
+ {
+ switch (varno)
+ {
+ case 19:
+ // jitter window
+ setJitterWindow(cfg.plunger.jitterWindow);
+ break;
+ }
+ }
+
// Set the jitter filter window size. This is specified in native
// sensor units.
void setJitterWindow(int w)
@@ -264,4 +287,217 @@
int jfLast; // last filtered reading
};
+
+// --------------------------------------------------------------------------
+//
+// Generic image sensor interface for image-based plungers
+//
+class PlungerSensorImageInterface
+{
+public:
+ PlungerSensorImageInterface(int npix)
+ {
+ native_npix = npix;
+ }
+
+ // initialize the sensor
+ virtual void init() = 0;
+
+ // is the sensor ready?
+ virtual bool ready() = 0;
+
+ // is a DMA transfer in progress?
+ virtual bool dmaBusy() = 0;
+
+ // read the image
+ virtual void readPix(uint8_t* &pix, uint32_t &t, int axcTime) = 0;
+
+ // Get an image for a pixel status report. 't' is the timestamp of
+ // the image. 'extraTime' is extra exposure time for the image, in
+ // 0.1ms increments.
+ virtual void getStatusReportPixels(
+ uint8_t* &pix, uint32_t &t, int axcTime, int extraTime) = 0;
+
+ // Reset the sensor after a status report. Status reports take a long
+ // time to send, so sensors that use continuous integration cycling may
+ // need to reset after a status report so that they aren't overexposed
+ // by the long delay of sending the status report.
+ virtual void resetAfterStatusReport(int axcTime) = 0;
+
+ // get the average sensor pixel scan time (the time it takes on average
+ // to read one image frame from the sensor)
+ virtual uint32_t getAvgScanTime() = 0;
+
+protected:
+ // number of pixels on sensor
+ int native_npix;
+};
+
+
+// ----------------------------------------------------------------------------
+//
+// Plunger base class for image-based sensors
+//
+template<class ProcessResult>
+class PlungerSensorImage: public PlungerSensor
+{
+public:
+ PlungerSensorImage(PlungerSensorImageInterface &sensor, int npix, int nativeScale)
+ : PlungerSensor(nativeScale), sensor(sensor)
+ {
+ axcTime = 0;
+ native_npix = npix;
+ }
+
+ // initialize the sensor
+ virtual void init() { sensor.init(); }
+
+ // is the sensor ready?
+ virtual bool ready() { return sensor.ready(); }
+
+ // is a DMA transfer in progress?
+ virtual bool dmaBusy() { return sensor.dmaBusy(); }
+
+ // get the pixel transfer time
+ virtual uint32_t getAvgScanTime() { return sensor.getAvgScanTime(); }
+
+ // read the plunger position
+ virtual bool readRaw(PlungerReading &r)
+ {
+ // read pixels from the sensor
+ uint8_t *pix;
+ uint32_t tpix;
+ sensor.readPix(pix, tpix, axcTime);
+
+ // process the pixels
+ int pixpos;
+ ProcessResult res;
+ if (process(pix, native_npix, pixpos, res))
+ {
+ r.pos = pixpos;
+ r.t = tpix;
+
+ // success
+ return true;
+ }
+ else
+ {
+ // no position found
+ return false;
+ }
+ }
+
+ // Send a status report to the joystick interface.
+ // See plunger.h for details on the arguments.
+ virtual void sendStatusReport(USBJoystick &js, uint8_t flags, uint8_t extraTime)
+ {
+ // get pixels
+ uint8_t *pix;
+ uint32_t t;
+ sensor.getStatusReportPixels(pix, t, axcTime, extraTime);
+
+ // start a timer to measure the processing time
+ Timer pt;
+ pt.start();
+
+ // process the pixels and read the position
+ int pos, rawPos;
+ int n = native_npix;
+ ProcessResult res;
+ if (process(pix, n, rawPos, res))
+ {
+ // success - apply the jitter filter
+ pos = jitterFilter(rawPos);
+ }
+ else
+ {
+ // report 0xFFFF to indicate that the position wasn't read
+ pos = 0xFFFF;
+ rawPos = 0xFFFF;
+ }
+
+ // note the processing time
+ uint32_t processTime = pt.read_us();
+
+ // If a low-res scan is desired, reduce to a subset of pixels. Ignore
+ // this for smaller sensors (below 512 pixels)
+ if ((flags & 0x01) && n >= 512)
+ {
+ // figure how many sensor pixels we combine into each low-res pixel
+ const int group = 8;
+ int lowResPix = n / group;
+
+ // combine the pixels
+ int src, dst;
+ for (src = dst = 0 ; dst < lowResPix ; ++dst)
+ {
+ // average this block of pixels
+ int a = 0;
+ for (int j = 0 ; j < group ; ++j)
+ a += pix[src++];
+
+ // we have the sum, so get the average
+ a /= group;
+
+ // store the down-res'd pixel in the array
+ pix[dst] = uint8_t(a);
+ }
+
+ // update the pixel count to the reduced array size
+ n = lowResPix;
+ }
+
+ // figure the report flags
+ int jsflags = 0;
+
+ // add flags for the detected orientation: 0x01 for normal orientation,
+ // 0x02 for reversed orientation; no flags if orientation is unknown
+ int dir = getOrientation();
+ if (dir == 1)
+ jsflags |= 0x01;
+ else if (dir == -1)
+ jsflags |= 0x02;
+
+ // send the sensor status report headers
+ js.sendPlungerStatus(n, pos, jsflags, sensor.getAvgScanTime(), processTime);
+ js.sendPlungerStatus2(nativeScale, jfLo, jfHi, rawPos, axcTime);
+
+ // send any extra status headers for subclasses
+ extraStatusHeaders(js, res);
+
+ // If we're not in calibration mode, send the pixels
+ extern bool plungerCalMode;
+ if (!plungerCalMode)
+ {
+ // send the pixels in report-sized chunks until we get them all
+ int idx = 0;
+ while (idx < n)
+ js.sendPlungerPix(idx, n, pix);
+ }
+
+ // reset the sensor, if necessary
+ sensor.resetAfterStatusReport(axcTime);
+ }
+
+protected:
+ // process an image to read the plunger position
+ virtual bool process(const uint8_t *pix, int npix, int &rawPos, ProcessResult &res) = 0;
+
+ // send extra status headers, following the standard headers (types 0 and 1)
+ virtual void extraStatusHeaders(USBJoystick &js, ProcessResult &res) { }
+
+ // get the detected orientation
+ virtual int getOrientation() const { return 0; }
+
+ // underlying hardware sensor interface
+ PlungerSensorImageInterface &sensor;
+
+ // number of pixels
+ int native_npix;
+
+ // auto-exposure time
+ uint32_t axcTime;
+};
+
+
#endif /* PLUNGER_H */
--- a/Plunger/tsl14xxSensor.h Fri Apr 21 18:50:37 2017 +0000
+++ b/Plunger/tsl14xxSensor.h Tue May 09 05:48:37 2017 +0000
@@ -15,35 +15,35 @@
#define _TSL14XXSENSOR_H_
#include "plunger.h"
+#include "edgeSensor.h"
+#include "barCodeSensor.h"
#include "TSL14xx.h"
-class PlungerSensorTSL14xx: public PlungerSensor
+class PlungerSensorImageInterfaceTSL14xx: public PlungerSensorImageInterface
{
public:
- PlungerSensorTSL14xx(int nativePix, int nativeScale,
- PinName si, PinName clock, PinName ao)
- : PlungerSensor(nativeScale),
- sensor(nativePix, si, clock, ao)
+ PlungerSensorImageInterfaceTSL14xx(int nativePix, PinName si, PinName clock, PinName ao)
+ : PlungerSensorImageInterface(nativePix), sensor(nativePix, si, clock, ao)
{
- // remember the native pixel size
- native_npix = nativePix;
-
- // start with no additional integration time for automatic
- // exposure control
- axcTime = 0;
}
// is the sensor ready?
virtual bool ready() { return sensor.ready(); }
+ // is a DMA transfer in progress?
+ virtual bool dmaBusy() { return sensor.dmaBusy(); }
+
virtual void init()
{
sensor.clear();
}
- // Send a status report to the joystick interface.
- // See plunger.h for details on the arguments.
- virtual void sendStatusReport(USBJoystick &js, uint8_t flags, uint8_t extraTime)
+ // get the average sensor scan time
+ virtual uint32_t getAvgScanTime() { return sensor.getAvgScanTime(); }
+
+protected:
+ virtual void getStatusReportPixels(
+ uint8_t* &pix, uint32_t &t, int axcTime, int extraTime)
{
// The sensor's internal buffering scheme makes it a little tricky
// to get the requested timing, and our own double-buffering adds a
@@ -90,85 +90,12 @@
// wait for the DMA transfer of period B to finish, and get the
// period B pixels
- uint8_t *pix;
- uint32_t t;
sensor.waitPix(pix, t);
-
- // start a timer to measure the processing time
- Timer pt;
- pt.start();
-
- // process the pixels and read the position
- int pos, rawPos;
- int n = native_npix;
- if (process(pix, n, rawPos))
- {
- // success - apply the jitter filter
- pos = jitterFilter(rawPos);
- }
- else
- {
- // report 0xFFFF to indicate that the position wasn't read
- pos = 0xFFFF;
- rawPos = 0xFFFF;
- }
-
- // note the processing time
- uint32_t processTime = pt.read_us();
-
- // If a low-res scan is desired, reduce to a subset of pixels. Ignore
- // this for smaller sensors (below 512 pixels)
- if ((flags & 0x01) && n >= 512)
- {
- // figure how many sensor pixels we combine into each low-res pixel
- const int group = 8;
- int lowResPix = n / group;
-
- // combine the pixels
- int src, dst;
- for (src = dst = 0 ; dst < lowResPix ; ++dst)
- {
- // average this block of pixels
- int a = 0;
- for (int j = 0 ; j < group ; ++j)
- a += pix[src++];
-
- // we have the sum, so get the average
- a /= group;
-
- // store the down-res'd pixel in the array
- pix[dst] = uint8_t(a);
- }
-
- // update the pixel count to the reduced array size
- n = lowResPix;
- }
-
- // figure the report flags
- int jsflags = 0;
-
- // add flags for the detected orientation: 0x01 for normal orientation,
- // 0x02 for reversed orientation; no flags if orientation is unknown
- int dir = getOrientation();
- if (dir == 1)
- jsflags |= 0x01;
- else if (dir == -1)
- jsflags |= 0x02;
-
- // send the sensor status report headers
- js.sendPlungerStatus(n, pos, jsflags, sensor.getAvgScanTime(), processTime);
- js.sendPlungerStatus2(nativeScale, jfLo, jfHi, rawPos, axcTime);
-
- // If we're not in calibration mode, send the pixels
- extern bool plungerCalMode;
- if (!plungerCalMode)
- {
- // send the pixels in report-sized chunks until we get them all
- int idx = 0;
- while (idx < n)
- js.sendPlungerPix(idx, n, pix);
- }
-
+ }
+
+ // reset after a status report
+ virtual void resetAfterStatusReport(int axcTime)
+ {
// It takes us a while to send all of the pixels, since we have
// to break them up into many USB reports. This delay means that
// the sensor has been sitting there integrating for much longer
@@ -179,39 +106,9 @@
sensor.clear();
sensor.startCapture(axcTime);
}
-
- // get the average sensor scan time
- virtual uint32_t getAvgScanTime() { return sensor.getAvgScanTime(); }
-
-protected:
- // Analyze the image and find the plunger position. If successful,
- // fills in 'pixpos' with the plunger position using the 0..65535
- // scale and returns true. If no position can be detected from the
- // image data, returns false.
- virtual bool process(const uint8_t *pix, int npix, int &pixpos) = 0;
-
- // Get the currently detected sensor orientation, if applicable.
- // Returns 1 for standard orientation, -1 for reversed orientation,
- // or 0 for orientation unknown or not applicable. Edge sensors can
- // automatically detect orientation by observing which side of the
- // image is in shadow. Bar code sensors generally can't detect
- // orientation.
- virtual int getOrientation() const { return 0; }
-
+
// the low-level interface to the TSL14xx sensor
TSL14xx sensor;
-
- // number of pixels
- int native_npix;
-
- // Automatic exposure control time, in microseconds. This is an amount
- // of time we add to each integration cycle to compensate for low light
- // levels. By default, this is always zero; the base class doesn't have
- // any logic for determining proper exposure, because that's a function
- // of the type of image we're looking for. Subclasses can add logic in
- // the process() function to check exposure level and adjust this value
- // if the image looks over- or under-exposed.
- uint32_t axcTime;
};
// ---------------------------------------------------------------------
@@ -245,42 +142,23 @@
// but that would complicate things considerably since our image
// analysis is too time-consuming to do in interrupt context.
//
-class PlungerSensorTSL14xxLarge: public PlungerSensorTSL14xx
+class PlungerSensorTSL14xxLarge: public PlungerSensorImageInterfaceTSL14xx
{
public:
- PlungerSensorTSL14xxLarge(int nativePix, int nativeScale,
- PinName si, PinName clock, PinName ao)
- : PlungerSensorTSL14xx(nativePix, nativeScale, si, clock, ao)
+ PlungerSensorTSL14xxLarge(int nativePix, PinName si, PinName clock, PinName ao)
+ : PlungerSensorImageInterfaceTSL14xx(nativePix, si, clock, ao)
{
}
- // read the plunger position
- virtual bool readRaw(PlungerReading &r)
- {
+ virtual void readPix(uint8_t* &pix, uint32_t &t, int axcTime)
+ {
// start reading the next pixel array (this waits for any DMA
// transfer in progress to finish, ensuring a stable pixel buffer)
sensor.startCapture(axcTime);
// get the image array from the last capture
- uint8_t *pix;
- uint32_t tpix;
- sensor.getPix(pix, tpix);
+ sensor.getPix(pix, t);
- // process the pixels
- int pixpos;
- if (process(pix, native_npix, pixpos))
- {
- r.pos = pixpos;
- r.t = tpix;
-
- // success
- return true;
- }
- else
- {
- // no position found
- return false;
- }
}
};
@@ -307,17 +185,16 @@
// transferring period A's pixels into a DMA buffer. We want
// those period A pixels, so we wait for this transfer to finish.
//
-class PlungerSensorTSL14xxSmall: public PlungerSensorTSL14xx
+class PlungerSensorTSL14xxSmall: public PlungerSensorImageInterfaceTSL14xx
{
public:
- PlungerSensorTSL14xxSmall(int nativePix, int nativeScale,
- PinName si, PinName clock, PinName ao)
- : PlungerSensorTSL14xx(nativePix, nativeScale, si, clock, ao)
+ PlungerSensorTSL14xxSmall(int nativePix, PinName si, PinName clock, PinName ao)
+ : PlungerSensorImageInterfaceTSL14xx(nativePix, si, clock, ao)
{
}
- // read the plunger position
- virtual bool readRaw(PlungerReading &r)
+ // read the image
+ virtual void readPix(uint8_t* &pix, uint32_t &t, int axcTime)
{
// Clear the sensor. This sends a HOLD/SI pulse to the sensor,
// which ends the current integration period, starts a new one
@@ -339,27 +216,55 @@
// wait for the period A pixel transfer to finish, and grab
// its pixels
- uint8_t *pix;
- uint32_t tpix;
- sensor.waitPix(pix, tpix);
-
- // process the pixels
- int pixpos;
- if (process(pix, native_npix, pixpos))
- {
- r.pos = pixpos;
- r.t = tpix;
-
- // success
- return true;
- }
- else
- {
- // no position found
- return false;
- }
+ sensor.waitPix(pix, t);
}
};
+// -------------------------------------------------------------------------
+//
+// Concrete TSL14xx sensor types
+//
+
+
+// TSL1410R sensor - edge detection sensor
+class PlungerSensorTSL1410R: public PlungerSensorEdgePos
+{
+public:
+ PlungerSensorTSL1410R(PinName si, PinName clock, PinName ao)
+ : PlungerSensorEdgePos(sensor, 1280), sensor(1280, si, clock, ao)
+ {
+ }
+
+protected:
+ PlungerSensorTSL14xxLarge sensor;
+};
+
+// TSL1412R - edge detection sensor
+class PlungerSensorTSL1412R: public PlungerSensorEdgePos
+{
+public:
+ PlungerSensorTSL1412R(PinName si, PinName clock, PinName ao)
+ : PlungerSensorEdgePos(sensor, 1536), sensor(1536, si, clock, ao)
+ {
+ }
+
+protected:
+ PlungerSensorTSL14xxLarge sensor;
+};
+
+// TSL1401CL - bar code sensor
+class PlungerSensorTSL1401CL: public PlungerSensorBarCode<7, 0, 1, 16>
+{
+public:
+ PlungerSensorTSL1401CL(PinName si, PinName clock, PinName ao)
+ : PlungerSensorBarCode(sensor, 128), sensor(128, si, clock, ao)
+ {
+ }
+
+protected:
+ PlungerSensorTSL14xxSmall sensor;
+};
+
+
#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/TLC59116/TLC59116.h Tue May 09 05:48:37 2017 +0000
@@ -0,0 +1,473 @@
+// TLC59116 interface
+//
+// The TLC59116 is a 16-channel constant-current PWM controller chip with
+// an I2C interface.
+//
+// Up to 14 of these chips can be connected to a single bus. Each chip needs
+// a unique address, configured via four pin inputs. (The I2C address is 7
+// bits, but the high-order 3 bits are fixed in the hardware, leaving 4 bits
+// to configure per chip. Two of the possible 16 addresses are reserved by
+// the chip hardware as broadcast addresses, leaving room for 14 unique chip
+// addresses per bus.)
+//
+// EXTERNAL PULL-UP RESISTORS ARE REQUIRED ON SDA AND SCL. The internal
+// pull-ups in the KL25Z GPIO ports will only work if the bus speed is
+// limited to 100kHz. Higher speeds require external pull-ups. Because
+// of the relatively high data rate required, we use the maximum 1MHz bus
+// speed, requiring external pull-ups. These are typically 2.2K.
+//
+// This chip is similar to the TLC5940, but has a more modern design with
+// several advantages, including a standardized and much more robust data
+// interface (I2C) and glitch-free startup. The only downside vs the TLC5940
+// is that it's only available in an SMD package, whereas the TLC5940 is
+// available in easy-to-solder DIP format. The DIP 5940 is longer being
+// manufactured, but it's still easy to find old stock; when those run out,
+// though, and the choice is between SMD 5940 and 59116, the 59116 will be
+// the clear winner.
+//
+
+#ifndef _TLC59116_H_
+#define _TLC59116_H_
+
+#include "mbed.h"
+#include "BitBangI2C.h"
+
+// Which I2C class are we using? We use this to switch between
+// BitBangI2C and MbedI2C for testing and debugging.
+#define I2C_Type BitBangI2C
+
+// register constants
+struct TLC59116R
+{
+ // control register bits
+ static const uint8_t CTL_AIALL = 0x80; // auto-increment mode, all registers
+ static const uint8_t CTL_AIPWM = 0xA0; // auto-increment mode, PWM registers only
+ static const uint8_t CTL_AICTL = 0xC0; // auto-increment mode, control registers only
+ static const uint8_t CTL_AIPWMCTL = 0xE0; // auto-increment mode, PWM + control registers only
+
+ // register addresses
+ static const uint8_t REG_MODE1 = 0x00; // MODE1
+ static const uint8_t REG_MODE2 = 0x01; // MODE2
+ static const uint8_t REG_PWM0 = 0x02; // PWM 0
+ static const uint8_t REG_PWM1 = 0x03; // PWM 1
+ static const uint8_t REG_PWM2 = 0x04; // PWM 2
+ static const uint8_t REG_PWM3 = 0x05; // PWM 3
+ static const uint8_t REG_PWM4 = 0x06; // PWM 4
+ static const uint8_t REG_PWM5 = 0x07; // PWM 5
+ static const uint8_t REG_PWM6 = 0x08; // PWM 6
+ static const uint8_t REG_PWM7 = 0x09; // PWM 7
+ static const uint8_t REG_PWM8 = 0x0A; // PWM 8
+ static const uint8_t REG_PWM9 = 0x0B; // PWM 9
+ static const uint8_t REG_PWM10 = 0x0C; // PWM 10
+ static const uint8_t REG_PWM11 = 0x0D; // PWM 11
+ static const uint8_t REG_PWM12 = 0x0E; // PWM 12
+ static const uint8_t REG_PWM13 = 0x0F; // PWM 13
+ static const uint8_t REG_PWM14 = 0x10; // PWM 14
+ static const uint8_t REG_PWM15 = 0x11; // PWM 15
+ static const uint8_t REG_GRPPWM = 0x12; // Group PWM duty cycle
+ static const uint8_t REG_GRPFREQ = 0x13; // Group frequency register
+ static const uint8_t REG_LEDOUT0 = 0x14; // LED driver output status register 0
+ static const uint8_t REG_LEDOUT1 = 0x15; // LED driver output status register 1
+ static const uint8_t REG_LEDOUT2 = 0x16; // LED driver output status register 2
+ static const uint8_t REG_LEDOUT3 = 0x17; // LED driver output status register 3
+
+ // MODE1 bits
+ static const uint8_t MODE1_AI2 = 0x80; // auto-increment mode enable
+ static const uint8_t MODE1_AI1 = 0x40; // auto-increment bit 1
+ static const uint8_t MODE1_AI0 = 0x20; // auto-increment bit 0
+ static const uint8_t MODE1_OSCOFF = 0x10; // oscillator off
+ static const uint8_t MODE1_SUB1 = 0x08; // subaddress 1 enable
+ static const uint8_t MODE1_SUB2 = 0x04; // subaddress 2 enable
+ static const uint8_t MODE1_SUB3 = 0x02; // subaddress 3 enable
+ static const uint8_t MODE1_ALLCALL = 0x01; // all-call enable
+
+ // MODE2 bits
+ static const uint8_t MODE2_EFCLR = 0x80; // clear error status flag
+ static const uint8_t MODE2_DMBLNK = 0x20; // group blinking mode
+ static const uint8_t MODE2_OCH = 0x08; // outputs change on ACK (vs Stop command)
+
+ // LEDOUTn states
+ static const uint8_t LEDOUT_OFF = 0x00; // driver is off
+ static const uint8_t LEDOUT_ON = 0x01; // fully on
+ static const uint8_t LEDOUT_PWM = 0x02; // individual PWM control via PWMn register
+ static const uint8_t LEDOUT_GROUP = 0x03; // PWM control + group dimming/blinking via PWMn + GRPPWM
+};
+
+
+// Individual unit object. We create one of these for each unit we
+// find on the bus. This keeps track of the state of each output on
+// a unit so that we can update outputs in batches, to reduce the
+// amount of time we spend in I2C communications during rapid updates.
+struct TLC59116Unit
+{
+ TLC59116Unit()
+ {
+ // start inactive, since we haven't been initialized yet
+ active = false;
+
+ // set all brightness levels to 0 intially
+ memset(bri, 0, sizeof(bri));
+
+ // mark all outputs as dirty to force an update after initializing
+ dirty = 0xFFFF;
+ }
+
+ // initialize
+ void init(int addr, I2C_Type &i2c)
+ {
+ // set all output drivers to individual PWM control
+ const uint8_t all_pwm =
+ TLC59116R::LEDOUT_PWM
+ | (TLC59116R::LEDOUT_PWM << 2)
+ | (TLC59116R::LEDOUT_PWM << 4)
+ | (TLC59116R::LEDOUT_PWM << 6);
+ static const uint8_t buf[] = {
+ TLC59116R::REG_LEDOUT0 | TLC59116R::CTL_AIALL,
+ all_pwm,
+ all_pwm,
+ all_pwm,
+ all_pwm
+ };
+ int err = i2c.write(addr << 1, buf, sizeof(buf));
+
+ // turn on the oscillator
+ static const uint8_t buf2[] = {
+ TLC59116R::REG_MODE1,
+ TLC59116R::MODE1_AI2 | TLC59116R::MODE1_ALLCALL
+ };
+ err |= i2c.write(addr << 1, buf2, sizeof(buf));
+
+ // mark the unit as active if the writes succeeded
+ active = !err;
+ }
+
+ // Set an output
+ void set(int idx, int val)
+ {
+ // validate the index
+ if (idx >= 0 && idx <= 15)
+ {
+ // record the new brightness
+ bri[idx] = val;
+
+ // set the dirty bit
+ dirty |= 1 << idx;
+ }
+ }
+
+ // Get an output's current value
+ int get(int idx) const
+ {
+ return idx >= 0 && idx <= 15 ? bri[idx] : -1;
+ }
+
+ // Send I2C updates
+ void send(int addr, I2C_Type &i2c)
+ {
+ // Scan all outputs. I2C sends are fairly expensive, so we
+ // minimize the send time by using the auto-increment mode.
+ // Optimizing this is a bit tricky. Suppose that the outputs
+ // are in this state, where c represents a clean output and D
+ // represents a dirty output:
+ //
+ // cccDcDccc...
+ //
+ // Clearly we want to start sending at the first dirty output
+ // so that we don't waste time sending the three clean bytes
+ // ahead of it. However, do we send output[3] as one chunk
+ // and then send output[5] as a separate chunk, or do we send
+ // outputs [3],[4],[5] as a single block to take advantage of
+ // the auto-increment mode? Based on I2C bus timing parameters,
+ // the answer is that it's cheaper to send this as a single
+ // contiguous block [3],[4],[5]. The reason is that the cost
+ // of starting a new block is a Stop/Start sequence plus another
+ // register address byte; the register address byte costs the
+ // same as a data byte, so the extra Stop/Start of the separate
+ // chunk approach makes the single continguous send cheaper.
+ // But how about this one?:
+ //
+ // cccDccDccc...
+ //
+ // This one is cheaper to send as two separate blocks. The
+ // break costs us a Start/Stop plus a register address byte,
+ // but the Start/Stop is only about 25% of the cost of a data
+ // byte, so Start/Stop+Register Address is cheaper than sending
+ // the two clean data bytes sandwiched between the dirty bytes.
+ //
+ // So: we want to look for sequences of contiguous dirty bytes
+ // and send those as a chunk. We furthermore will allow up to
+ // one clean byte in the midst of the dirty bytes.
+ uint8_t buf[17];
+ int n = 0;
+ for (int i = 0, bit = 1 ; i < 16 ; ++i, bit <<= 1)
+ {
+ // If this one is dirty, include it in the set of outputs to
+ // send to the chip. Also include this one if it's clean
+ // and the outputs on both sides are dirty - see the notes
+ // above about optimizing for the case where we have one clean
+ // output surrounded by dirty outputs.
+ if ((dirty & bit) != 0)
+ {
+ // it's dirty - add it to the dirty set under construction
+ buf[++n] = bri[i];
+ }
+ else if (n != 0 && n < 15 && (dirty & (bit << 1)) != 0)
+ {
+ // this one is clean, but the one before and the one after
+ // are both dirty, so keep it in the set anyway to take
+ // advantage of the auto-increment mode for faster sends
+ buf[++n] = bri[i];
+ }
+ else
+ {
+ // This one is clean, and it's not surrounded by dirty
+ // outputs. If the set of dirty outputs so far has any
+ // members, send them now.
+ if (n != 0)
+ {
+ // set the starting register address, including the
+ // auto-increment flag, and write the block
+ buf[0] = (TLC59116R::REG_PWM0 + i - n) | TLC59116R::CTL_AIALL;
+ i2c.write(addr << 1, buf, n + 1);
+
+ // empty the set
+ n = 0;
+ }
+ }
+ }
+
+ // if we finished the loop with dirty outputs to send, send them
+ if (n != 0)
+ {
+ // fill in the starting register address, and write the block
+ buf[0] = (TLC59116R::REG_PWM15 + 1 - n) | TLC59116R::CTL_AIALL;
+ i2c.write(addr << 1, buf, n + 1);
+ }
+
+ // all outputs are now clean
+ dirty = 0;
+ }
+
+ // Is the unit active? If we have trouble writing a unit,
+ // we can mark it inactive so that we know to stop wasting
+ // time writing to it, and so that we can re-initialize it
+ // if it comes back on later bus scans.
+ bool active;
+
+ // Output states. This records the latest brightness level
+ // for each output as set by the client. We don't actually
+ // send these values to the physical unit until the client
+ // tells us to do an I2C update.
+ uint8_t bri[16];
+
+ // Dirty output mask. Whenever the client changes an output,
+ // we record the new brightness in bri[] and set the
+ // corresponding bit here to 1. We use these bits to determine
+ // which outputs to send during each I2C update.
+ uint16_t dirty;
+};
+
+// TLC59116 public interface. This provides control over a collection
+// of units connected on a common I2C bus.
+class TLC59116
+{
+public:
+ // Initialize. The address given is the configurable part
+ // of the address, 0x0000 to 0x000F.
+ TLC59116(PinName sda, PinName scl, PinName reset)
+ : i2c(sda, scl, true), reset(reset)
+ {
+ // Use the fastest I2C speed possible, since we want to be able
+ // to rapidly update many outputs at once. The TLC59116 can run
+ // I2C at up to 1MHz.
+ i2c.frequency(1000000);
+
+ // assert !RESET until we're ready to go
+ this->reset.write(0);
+
+ // there are no units yet
+ memset(units, 0, sizeof(units));
+ nextUpdate = 0;
+ }
+
+ void init()
+ {
+ // un-assert reset
+ reset.write(1);
+ wait_us(10000);
+
+ // scan the bus for new units
+ scanBus();
+ }
+
+ // scan the bus
+ void scanBus()
+ {
+ // scan each possible address
+ for (int i = 0 ; i < 16 ; ++i)
+ {
+ // Address 8 and 11 are reserved - skip them
+ if (i == 8 || i == 11)
+ continue;
+
+ // Try reading register REG_MODE1
+ int addr = I2C_BASE_ADDR | i;
+ TLC59116Unit *u = units[i];
+ if (readReg8(addr, TLC59116R::REG_MODE1) >= 0)
+ {
+ // success - if the slot wasn't already populated, allocate
+ // a unit entry for it
+ if (u == 0)
+ units[i] = u = new TLC59116Unit();
+
+ // if the unit isn't already marked active, initialize it
+ if (!u->active)
+ u->init(addr, i2c);
+ }
+ else
+ {
+ // failed - if the unit was previously active, mark it
+ // as inactive now
+ if (u != 0)
+ u->active = false;
+ }
+ }
+ }
+
+ // set an output
+ void set(int unit, int output, int val)
+ {
+ if (unit >= 0 && unit <= 15)
+ {
+ TLC59116Unit *u = units[unit];
+ if (u != 0)
+ u->set(output, val);
+ }
+ }
+
+ // get an output's current value
+ int get(int unit, int output)
+ {
+ if (unit >= 0 && unit <= 15)
+ {
+ TLC59116Unit *u = units[unit];
+ if (u != 0)
+ return u->get(output);
+ }
+
+ return -1;
+ }
+
+ // Send I2C updates to the next unit. The client must call this
+ // periodically to send pending updates. We only update one unit on
+ // each call to ensure that the time per cycle is relatively constant
+ // (rather than scaling with the number of chips).
+ void send()
+ {
+ // look for a dirty unit
+ for (int i = 0, n = nextUpdate ; i < 16 ; ++i, ++n)
+ {
+ // wrap the unit number
+ n &= 0x0F;
+
+ // if this unit is populated and dirty, it's the one to update
+ TLC59116Unit *u = units[n];
+ if (u != 0 && u->dirty != 0)
+ {
+ // it's dirty - update it
+ u->send(I2C_BASE_ADDR | n, i2c);
+
+ // We only update one on each call, so we're done.
+ // Remember where to pick up again on the next update()
+ // call, and return.
+ nextUpdate = n + 1;
+ return;
+ }
+ }
+ }
+
+ // Enable/disable all outputs
+ void enable(bool f)
+ {
+ // visit each populated unit
+ for (int i = 0 ; i < 16 ; ++i)
+ {
+ // if this unit is populated, enable/disable it
+ TLC59116Unit *u = units[i];
+ if (u != 0)
+ {
+ // read the current MODE1 register
+ int m = readReg8(I2C_BASE_ADDR | i, TLC59116R::REG_MODE1);
+ if (m >= 0)
+ {
+ // Turn the oscillator off to disable, on to enable.
+ // Note that the bit is kind of backwards: SETTING the
+ // OSC bit turns the oscillator OFF.
+ if (f)
+ m &= ~TLC59116R::MODE1_OSCOFF; // enable - clear the OSC bit
+ else
+ m |= TLC59116R::MODE1_OSCOFF; // disable - set the OSC bit
+
+ // update MODE1
+ writeReg8(I2C_BASE_ADDR | i, TLC59116R::REG_MODE1, m);
+ }
+ }
+ }
+ }
+
+protected:
+ // TLC59116 base I2C address. These chips use an address of
+ // the form 110xxxx, where the the low four bits are set by
+ // external pins on the chip. The top three bits are always
+ // the same, so we construct the full address by combining
+ // the upper three fixed bits with the four-bit unit number.
+ //
+ // Note that addresses 1101011 (0x6B) and 1101000 (0x68) are
+ // reserved (for SWRSTT and ALLCALL, respectively), and can't
+ // be used for configured device addresses.
+ static const uint8_t I2C_BASE_ADDR = 0x60;
+
+ // Units. We populate this with active units we find in
+ // bus scans. Note that units 8 and 11 can't be used because
+ // of the reserved ALLCALL and SWRST addresses, but we allocate
+ // the slots anyway to keep indexing simple.
+ TLC59116Unit *units[16];
+
+ // next unit to update
+ int nextUpdate;
+
+ // read 8-bit register; returns the value read on success, -1 on failure
+ int readReg8(int addr, uint16_t registerAddr)
+ {
+ // write the request - register address + auto-inc mode
+ uint8_t data_write[1];
+ data_write[0] = registerAddr | TLC59116R::CTL_AIALL;
+ if (i2c.write(addr << 1, data_write, 1, true))
+ return -1;
+
+ // read the result
+ uint8_t data_read[1];
+ if (i2c.read(addr << 1, data_read, 1))
+ return -1;
+
+ // return the result
+ return data_read[0];
+ }
+
+ // write 8-bit register; returns true on success, false on failure
+ bool writeReg8(int addr, uint16_t registerAddr, uint8_t data)
+ {
+ uint8_t data_write[2];
+ data_write[0] = registerAddr | TLC59116R::CTL_AIALL;
+ data_write[1] = data;
+ return !i2c.write(addr << 1, data_write, 2);
+ }
+
+ // I2C bus interface
+ I2C_Type i2c;
+
+ // reset pin (active low)
+ DigitalOut reset;
+};
+
+#endif
--- a/TLC5940/TLC5940.h Fri Apr 21 18:50:37 2017 +0000
+++ b/TLC5940/TLC5940.h Tue May 09 05:48:37 2017 +0000
@@ -392,16 +392,6 @@
}
}
- // Update the outputs. In our current implementation, this doesn't do
- // anything, since we send the current state to the chips on every grayscale
- // cycle, whether or not there are updates. We provide the interface for
- // consistency with other peripheral device interfaces in the main loop,
- // and in case we make any future implementation changes that require some
- // action to carry out an explicit update.
- void update(bool force = false)
- {
- }
-
// Send updates if ready. Our top-level program's main loop calls this on
// every iteration. This lets us send grayscale updates to the chips in
// regular application context (rather than in interrupt context), to keep
--- a/TSL14xx/TSL14xx.h Fri Apr 21 18:50:37 2017 +0000
+++ b/TSL14xx/TSL14xx.h Tue May 09 05:48:37 2017 +0000
@@ -480,6 +480,9 @@
// Is the latest reading ready?
bool ready() const { return !running; }
+
+ // Is a DMA transfer in progress?
+ bool dmaBusy() const { return running; }
// Clock through all pixels to clear the array. Pulses SI at the
// beginning of the operation, which starts a new integration cycle.
--- a/USBJoystick/USBJoystick.cpp Fri Apr 21 18:50:37 2017 +0000
+++ b/USBJoystick/USBJoystick.cpp Tue May 09 05:48:37 2017 +0000
@@ -94,7 +94,7 @@
}
bool USBJoystick::sendPlungerStatus(
- int npix, int edgePos, int flags, uint32_t avgScanTime, uint32_t processingTime)
+ int npix, int plungerPos, int flags, uint32_t avgScanTime, uint32_t processingTime)
{
HID_REPORT report;
@@ -112,8 +112,8 @@
put(ofs, uint16_t(npix));
ofs += 2;
- // write the shadow edge position to bytes 5-6
- put(ofs, uint16_t(edgePos));
+ // write the detected plunger position to bytes 5-6
+ put(ofs, uint16_t(plungerPos));
ofs += 2;
// Add the calibration mode flag if applicable
@@ -191,6 +191,45 @@
return sendTO(&report, 100);
}
+bool USBJoystick::sendPlungerStatusBarcode(
+ int nbits, int codetype, int startOfs, int pixPerBit, int raw, int mask)
+{
+ HID_REPORT report;
+ memset(report.data, 0, sizeof(report.data));
+
+ // Set the special status bits to indicate it's an extended
+ // exposure report.
+ put(0, 0x87FF);
+
+ // start at the second byte
+ int ofs = 2;
+
+ // write the report subtype (2) to byte 2
+ report.data[ofs++] = 2;
+
+ // write the bit count and code type
+ report.data[ofs++] = nbits;
+ report.data[ofs++] = codetype;
+
+ // write the bar code starting pixel offset
+ put(ofs, uint16_t(startOfs));
+ ofs += 2;
+
+ // write the pixel width per bit
+ report.data[ofs++] = pixPerBit;
+
+ // write the raw bar code and success bit mask
+ put(ofs, uint16_t(raw));
+ ofs += 2;
+ put(ofs, uint16_t(mask));
+ ofs += 2;
+
+ // send the report
+ report.length = reportLen;
+ return sendTO(&report, 100);
+}
+
+
bool USBJoystick::sendPlungerPix(int &idx, int npix, const uint8_t *pix)
{
HID_REPORT report;
--- a/USBJoystick/USBJoystick.h Fri Apr 21 18:50:37 2017 +0000
+++ b/USBJoystick/USBJoystick.h Tue May 09 05:48:37 2017 +0000
@@ -176,6 +176,18 @@
*/
bool sendPlungerStatus2(
int nativeScale, int jitterLo, int jitterHi, int rawPos, int axcTime);
+
+ /**
+ * Send a barcode plunger status report header.
+ *
+ * @param nbits number of bits in bar code
+ * @param codetype bar code type (1=Gray code/Manchester bit coding)
+ * @param pixofs pixel offset of first bit
+ * @param raw raw bar code bits
+ * @param mask mask of successfully read bar code bits
+ */
+ bool sendPlungerStatusBarcode(
+ int nbits, int codetype, int startOfs, int pixPerBit, int raw, int mask);
/**
* Write an exposure report. We'll fill out a report with as many pixels as
--- a/USBProtocol.h Fri Apr 21 18:50:37 2017 +0000 +++ b/USBProtocol.h Tue May 09 05:48:37 2017 +0000 @@ -172,6 +172,21 @@ // status as of this reading. // bytes 9:10 = Raw sensor reading before jitter filter was applied. // bytes 11:12 = Auto-exposure time in microseconds +// +// An optional third message provides additional information specifically +// for bar-code sensors: +// +// bytes 0:1 = 0x87FF +// byte 2 = 2 -> bar code status report +// byte 3 = number of bits in bar code +// byte 4 = bar code type: +// 1 = Gray code/Manchester bit coding +// bytes 5:6 = pixel offset of first bit +// byte 7 = width in pixels of each bit +// bytes 8:9 = raw bar code bits +// bytes 10:11 = mask of successfully read bar code bits; a '1' bit means +// that the bit was read successfully, '0' means the bit was +// unreadable // // // If the sensor is an imaging sensor type, this will be followed by a @@ -182,7 +197,7 @@ // zero, so obviously no pixel packets will follow. If the "calibration // active" bit in the flags byte is set, no pixel packets are sent even // if the sensor is an imaging type, since the transmission time for the -// pixels would intefere with the calibration process. If pixels are sent, +// pixels would interfere with the calibration process. If pixels are sent, // they're sent in order starting at the first pixel. The format of each // pixel packet is: // @@ -898,7 +913,7 @@ // finishes. This allows TVs to be turned on via IR remotes codes rather than // hard-wiring them through the relay. The relay can be omitted in this case. // -// 10 -> TLC5940NT setup. This chip is an external PWM controller, with 32 outputs +// 10 -> TLC5940NT setup. This chip is an external PWM controller, with 16 outputs // per chip and a serial data interface that allows the chips to be daisy- // chained. We can use these chips to add an arbitrary number of PWM output // ports for the LedWiz emulation. @@ -1072,6 +1087,44 @@ // // byte 3:4 = window size in joystick units, little-endian // +// 20 -> Plunger bar code setup. Sets parameters applicable only to bar code +// sensor types. +// +// bytes 3:4 = Starting pixel offset of bar code (margin width) +// +// 21 -> TLC59116 setup. This chip is an external PWM controller with 16 +// outputs per chip and an I2C bus interface. Up to 14 of the chips +// can be connected to a single bus. This chip is a successor to the +// TLC5940 with a more modern design and some nice improvements, such +// as glitch-free startup and a standard (I2C) physical interface. +// +// Each chip has a 7-bit I2C address. The top three bits of the +// address are fixed in the chip itself and can't be configured, but +// the low four bits are configurable via the address line pins on +// the chip, A3 A2 A1 A0. Our convention here is to ignore the fixed +// three bits and refer to the chip address as just the A3 A2 A1 A0 +// bits. This gives each chip an address from 0 to 15. +// +// I2C allows us to discover the attached chips automatically, so in +// principle we don't need to know which chips will be present. +// However, it's useful for the config tool to know which chips are +// expected so that it can offer them in the output port setup UI. +// We therefore provide a bit mask specifying the enabled chips. Each +// bit specifies whether the chip at the corresponding address is +// present: 0x0001 is the chip at address 0, 0x0002 is the chip at +// address 1, etc. This is mostly for the config tool's use; we only +// use it to determine if TLC59116 support should be enabled at all, +// by checking if it's non-zero. +// +// To disable support, set the populated chip mask to 0. The pin +// assignments are all ignored in this case. +// +// bytes 3:4 = populated chips, as a bit mask (OR in 1<<address +// each populated address) +// byte 5 = SDA (any GPIO pin) +// byte 6 = SCL (any GPIO pin) +// byte 7 = RESET (any GPIO pin) +// // // SPECIAL DIAGNOSTICS VARIABLES: These work like the array variables below, // the only difference being that we don't report these in the number of array @@ -1225,42 +1278,63 @@ // regardless of the settings for post 34 and higher. // // The bytes of the message are: +// // byte 3 = LedWiz port number (1 to MAX_OUT_PORTS) +// // byte 4 = physical output type: +// // 0 = Disabled. This output isn't used, and isn't visible to the // LedWiz/DOF software on the host. The FIRST disabled port // determines the number of ports visible to the host - ALL ports // after the first disabled port are also implicitly disabled. +// // 1 = GPIO PWM output: connected to GPIO pin specified in byte 5, // operating in PWM mode. Note that only a subset of KL25Z GPIO // ports are PWM-capable. +// // 2 = GPIO Digital output: connected to GPIO pin specified in byte 5, // operating in digital mode. Digital ports can only be set ON // or OFF, with no brightness/intensity control. All pins can be // used in this mode. +// // 3 = TLC5940 port: connected to TLC5940 output port number specified // in byte 5. Ports are numbered sequentially starting from port 0 // for the first output (OUT0) on the first chip in the daisy chain. +// // 4 = 74HC595 port: connected to 74HC595 output port specified in byte 5. // As with the TLC5940 outputs, ports are numbered sequentially from 0 // for the first output on the first chip in the daisy chain. +// // 5 = Virtual output: this output port exists for the purposes of the // LedWiz/DOF software on the host, but isn't physically connected // to any output device. This can be used to create a virtual output // for the DOF ZB Launch Ball signal, for example, or simply as a // placeholder in the LedWiz port numbering. The physical output ID // (byte 5) is ignored for this port type. +// +// 6 = TLC59116 output: connected to the TLC59116 output port specified +// in byte 5. The high four bits of this value give the chip's +// I2C address, specifically the A3 A2 A1 A0 bits configured in +// the hardware. (A chip's I2C address is actually 7 bits, but +// the three high-order bits are fixed, so we don't bother including +// those in the byte 5 value). The low four bits of this value +// give the output port number on the chip. For example, 0x37 +// specifies chip 3 (the one with A3 A2 A1 A0 wired as 0 0 1 1), +// output #7 on that chip. Note that outputs are numbered from 0 +// to 15 (0xF) on each chip. +// // byte 5 = physical output port, interpreted according to the value in byte 4 +// // byte 6 = flags: a combination of these bit values: // 0x01 = active-high output (0V on output turns attached device ON) // 0x02 = noisemaker device: disable this output when "night mode" is engaged // 0x04 = apply gamma correction to this output // -// Note that the on-board LED segments can be used as LedWiz output ports. This +// Note that the KL25Z's on-board LEDs can be used as LedWiz output ports. This // is useful for testing a new installation with DOF or other PC software without -// having to connect any external devices. Assigning the on-board LED segments to -// output ports overrides their normal status/diagnostic display use, so the normal -// status flash pattern won't appear when they're used this way. +// having to connect any external devices. Assigning the on-board LEDs as output +// ports overrides their normal status/diagnostic display use, so the normal status +// flash pattern won't appear when they're used this way. //
--- a/VL6180X/VL6180X.cpp Fri Apr 21 18:50:37 2017 +0000
+++ b/VL6180X/VL6180X.cpp Tue May 09 05:48:37 2017 +0000
@@ -3,16 +3,19 @@
#include "mbed.h"
#include "VL6180X.h"
-VL6180X::VL6180X(PinName sda, PinName scl, uint8_t addr, PinName gpio0)
- : i2c(sda, scl), gpio0Pin(gpio0)
+VL6180X::VL6180X(PinName sda, PinName scl, uint8_t addr, PinName gpio0,
+ bool internalPullups)
+ : i2c(sda, scl, internalPullups), gpio0Pin(gpio0)
{
// remember the address
this->addr = addr;
// start in single-shot distance mode
distMode = 0;
+ rangeStarted = false;
- // initially reset the sensor
+ // initially reset the sensor by holding GPIO0/CE low
+ gpio0Pin.mode(PullNone);
gpio0Pin.output();
gpio0Pin.write(0);
}
@@ -28,10 +31,10 @@
gpio0Pin.write(0);
wait_us(10000);
- // release reset to allow the sensor to reboot
+ // release reset and allow 10ms for the sensor to reboot
gpio0Pin.input();
wait_us(10000);
-
+
// reset the I2C bus
i2c.reset();
@@ -40,7 +43,7 @@
t.start();
while (readReg8(VL6180X_SYSTEM_FRESH_OUT_OF_RESET) != 1)
{
- if (t.read_us() > 10000000)
+ if (t.read_us() > 1000000)
return false;
}
@@ -85,7 +88,10 @@
// allow time to settle
wait_us(1000);
-
+
+ // start the sample timer
+ sampleTimer.start();
+
// success
return true;
}
@@ -94,20 +100,16 @@
{
writeReg8(VL6180X_SYSTEM_GROUPED_PARAMETER_HOLD, 0x01); // set parameter hold while updating settings
- writeReg8(VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, (4<<3) | 4); // Enable interrupts from range and ambient integrator
- writeReg8(VL6180X_SYSTEM_MODE_GPIO1, 0x10); // Set GPIO1 low when sample complete
+ writeReg8(VL6180X_SYSTEM_INTERRUPT_CONFIG_GPIO, 4); // Enable interrupts from range only
+ writeReg8(VL6180X_SYSTEM_MODE_GPIO1, 0x00); // Disable GPIO1
writeReg8(VL6180X_SYSRANGE_VHV_REPEAT_RATE, 0xFF); // Set auto calibration period (Max = 255)/(OFF = 0)
writeReg8(VL6180X_SYSRANGE_INTERMEASUREMENT_PERIOD, 0x09); // Set default ranging inter-measurement period to 100ms
- writeReg8(VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME, 0x32); // Max range convergence time 48ms
- writeReg8(VL6180X_SYSRANGE_RANGE_CHECK_ENABLES, 0x11); // S/N enable, ignore disable, early convergence test enable
- writeReg16(VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, 0x7B); // abort range measurement if convergence rate below this value
-
- writeReg8(VL6180X_SYSALS_INTERMEASUREMENT_PERIOD, 0x0A); // Set default ALS inter-measurement period to 100ms
- writeReg8(VL6180X_SYSALS_ANALOGUE_GAIN, 0x46); // Set the ALS gain
- writeReg16(VL6180X_SYSALS_INTEGRATION_PERIOD, 0x63); // ALS integration time 100ms
-
- writeReg8(VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD, 0x30); // Sample averaging period (1.3ms + N*64.5us)
- writeReg8(VL6180X_FIRMWARE_RESULT_SCALER, 0x01);
+ writeReg8(VL6180X_SYSRANGE_MAX_CONVERGENCE_TIME, 63); // Max range convergence time 63ms
+ writeReg8(VL6180X_SYSRANGE_RANGE_CHECK_ENABLES, 0x00); // S/N disable, ignore disable, early convergence test disable
+ writeReg16(VL6180X_SYSRANGE_EARLY_CONVERGENCE_ESTIMATE, 0x00); // abort range measurement if convergence rate below this value
+ writeReg8(VL6180X_READOUT_AVERAGING_SAMPLE_PERIOD, averagingSamplePeriod); // Sample averaging period (1.3ms + N*64.5us)
+ writeReg8(VL6180X_SYSRANGE_THRESH_LOW, 0x00); // low threshold
+ writeReg8(VL6180X_SYSRANGE_THRESH_HIGH, 0xff); // high threshold
writeReg8(VL6180X_SYSTEM_GROUPED_PARAMETER_HOLD, 0x00); // end parameter hold
@@ -118,7 +120,7 @@
while (readReg8(VL6180X_SYSRANGE_VHV_RECALIBRATE) != 0)
{
// if we've been waiting too long, abort
- if (t.read_us() > 1000000)
+ if (t.read_us() > 100000)
break;
}
}
@@ -141,25 +143,7 @@
id.manufDate.mm = (time % 3600) / 60;
id.manufDate.ss = time % 60;
}
-
-
-uint8_t VL6180X::changeAddress(uint8_t newAddress)
-{
- // do nothing if the address is the same or it's out of range
- if (newAddress == addr || newAddress > 127)
- return addr;
- // set the new address
- writeReg8(VL6180X_I2C_SLAVE_DEVICE_ADDRESS, newAddress);
-
- // read it back and store it
- addr = readReg8(VL6180X_I2C_SLAVE_DEVICE_ADDRESS);
-
- // return the new address
- return addr;
-}
-
-
void VL6180X::continuousDistanceMode(bool on)
{
if (distMode != on)
@@ -184,31 +168,48 @@
bool VL6180X::rangeReady()
{
- return (readReg8(VL6180X_RESULT_INTERRUPT_STATUS_GPIO) & 0x07) == 4;
+ // check if the status register says a sample is ready (bits 0-2/0x07)
+ // or an error has occurred (bits 6-7/0xC0)
+ return ((readReg8(VL6180X_RESULT_INTERRUPT_STATUS_GPIO) & 0xC7) != 0);
}
void VL6180X::startRangeReading()
{
- writeReg8(VL6180X_SYSRANGE_START, 0x01);
+ // start a new range reading if one isn't already in progress
+ if (!rangeStarted)
+ {
+ tSampleStart = sampleTimer.read_us();
+ writeReg8(VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07);
+ writeReg8(VL6180X_SYSRANGE_START, 0x00);
+ writeReg8(VL6180X_SYSRANGE_START, 0x01);
+ rangeStarted = true;
+ }
}
-int VL6180X::getRange(uint8_t &distance, uint32_t timeout_us)
+int VL6180X::getRange(uint8_t &distance, uint32_t &tMid, uint32_t &dt, uint32_t timeout_us)
{
- if (!rangeReady())
- writeReg8(VL6180X_SYSRANGE_START, 0x01);
+ // start a reading if one isn't already in progress
+ startRangeReading();
+
+ // we're going to wait until this reading ends, so consider the
+ // 'start' command consumed, no matter what happens next
+ rangeStarted = false;
// wait for the sample
Timer t;
t.start();
for (;;)
{
- // if the GPIO pin is high, the sample is ready
+ // check for a sample
if (rangeReady())
break;
// if we've exceeded the timeout, return failure
if (t.read_us() > timeout_us)
+ {
+ writeReg8(VL6180X_SYSRANGE_START, 0x00);
return -1;
+ }
}
// check for errors
@@ -217,6 +218,22 @@
// read the distance
distance = readReg8(VL6180X_RESULT_RANGE_VAL);
+ // Read the convergence time, and compute the overall sample time.
+ // Per the data sheet, the total execution time is the sum of the
+ // fixed 3.2ms pre-calculation time, the convergence time, and the
+ // readout averaging time. We can query the convergence time for
+ // each reading from the sensor. The averaging time is a controlled
+ // by the READOUT_AVERAGING_SAMPLE_PERIOD setting, which we set to
+ // our constant value averagingSamplePeriod.
+ dt =
+ 3200 // fixed 3.2ms pre-calculation period
+ + readReg32(VL6180X_RESULT_RANGE_RETURN_CONV_TIME) // convergence time
+ + (1300 + 48*averagingSamplePeriod); // readout averaging period
+
+ // figure the midpoint of the sample time - the starting time
+ // plus half the collection time
+ tMid = tSampleStart + dt/2;
+
// clear the data-ready interrupt
writeReg8(VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07);
@@ -236,53 +253,13 @@
stats.refConvTime = readReg32(VL6180X_RESULT_RANGE_REFERENCE_CONV_TIME);
}
-float VL6180X::getAmbientLight(VL6180X_ALS_Gain gain)
-{
- // set the desired gain
- writeReg8(VL6180X_SYSALS_ANALOGUE_GAIN, (0x40 | gain));
-
- // start the integration
- writeReg8(VL6180X_SYSALS_START, 0x01);
-
- // give it time to integrate
- wait_ms(100);
-
- // clear the data-ready interrupt
- writeReg8(VL6180X_SYSTEM_INTERRUPT_CLEAR, 0x07);
-
- // retrieve the raw sensor reading om the sensoe
- unsigned int alsRaw = readReg16(VL6180X_RESULT_ALS_VAL);
-
- // get the integration period
- unsigned int tIntRaw = readReg16(VL6180X_SYSALS_INTEGRATION_PERIOD);
- float alsIntegrationPeriod = 100.0 / tIntRaw ;
-
- // get the actual gain at the user's gain setting
- float trueGain = 0.0;
- switch (gain)
- {
- case GAIN_20: trueGain = 20.0; break;
- case GAIN_10: trueGain = 10.32; break;
- case GAIN_5: trueGain = 5.21; break;
- case GAIN_2_5: trueGain = 2.60; break;
- case GAIN_1_67: trueGain = 1.72; break;
- case GAIN_1_25: trueGain = 1.28; break;
- case GAIN_1: trueGain = 1.01; break;
- case GAIN_40: trueGain = 40.0; break;
- default: trueGain = 1.0; break;
- }
-
- // calculate the lux (see the manufacturer's app notes)
- return alsRaw * 0.32f / trueGain * alsIntegrationPeriod;
-}
-
uint8_t VL6180X::readReg8(uint16_t registerAddr)
{
// write the request - MSB+LSB of register address
uint8_t data_write[2];
data_write[0] = (registerAddr >> 8) & 0xFF;
data_write[1] = registerAddr & 0xFF;
- if (i2c.write(addr << 1, data_write, 2, true))
+ if (i2c.write(addr << 1, data_write, 2, false))
return 0x00;
// read the result
@@ -300,7 +277,7 @@
uint8_t data_write[2];
data_write[0] = (registerAddr >> 8) & 0xFF;
data_write[1] = registerAddr & 0xFF;
- if (i2c.write(addr << 1, data_write, 2, true))
+ if (i2c.write(addr << 1, data_write, 2, false))
return 0;
// read the result
--- a/VL6180X/VL6180X.h Fri Apr 21 18:50:37 2017 +0000
+++ b/VL6180X/VL6180X.h Tue May 09 05:48:37 2017 +0000
@@ -7,23 +7,6 @@
#include "BitBangI2C.h"
-class MyI2C: public I2C
-{
-public:
- MyI2C(PinName sda, PinName scl) : I2C(sda, scl) { }
-
- int write(int addr, const uint8_t *data, size_t len, bool repeated = false)
- {
- return I2C::write(addr, (const char *)data, len, repeated);
- }
- int read(int addr, uint8_t *data, size_t len, bool repeated = false)
- {
- return I2C::read(addr, (char *)data, len, repeated);
- }
-
- void reset() { }
-};
-
#define VL6180X_IDENTIFICATION_MODEL_ID 0x0000
#define VL6180X_IDENTIFICATION_MODEL_REV_MAJOR 0x0001
#define VL6180X_IDENTIFICATION_MODEL_REV_MINOR 0x0002
@@ -135,12 +118,19 @@
{
public:
// Set up the interface with the given I2C pins, I2C address, and
- // the GPIO0 pin (for resetting the sensor at startup).
+ // the GPIO0 pin (for resetting the sensor at startup).
+ //
+ // If 'internalPullups' is true, we'll set the I2C SDA/SCL pins to
+ // enable the internal pullup resistors. Set this to false if you're
+ // using your own external pullup resistors on the lines. External
+ // pullups are better if you're attaching more than one device to the
+ // same I2C bus; the internal pullups are fine for a single device.
//
// Note that the power-on default I2C address is always 0x29. The
// address can be changed during a session, but it's not saved
// persistently; it always resets to 0x29 on the next power cycle.
- VL6180X(PinName sda, PinName scl, uint8_t addr, PinName gpio0);
+ VL6180X(PinName sda, PinName scl, uint8_t addr, PinName gpio0,
+ bool internalPullups);
// destruction
~VL6180X();
@@ -159,7 +149,15 @@
// Get TOF range distance in mm. Returns 0 on success, a device
// "range error code" (>0) on failure, or -1 on timeout.
- int getRange(uint8_t &distance, uint32_t timeout_us);
+ //
+ // 'tMid' is the timestamp in microseconds of the midpoint of the
+ // sample, relative to an arbitrary zero point. This can be used
+ // to construct a timeline of successive readings, such as for
+ // velocity calculations. 'dt' is the time the sensor took to
+ // collect the sample.
+ int getRange(
+ uint8_t &distance, uint32_t &tMid, uint32_t &dt,
+ uint32_t timeout_us);
// get range statistics
void getRangeStats(VL6180X_RangeStats &stats);
@@ -170,17 +168,15 @@
// is a sample ready?
bool rangeReady();
- // get ambient light level in lux
- float getAmbientLight(VL6180X_ALS_Gain gain);
-
// get identification data
void getID(VL6180X_ID &id);
- // Change the address of the device. Returns the new address.
- uint8_t changeAddress(uint8_t newAddress);
-
+protected:
+ // READOUT_AVERAGING_SAMPLE_PERIOD setting. Each unit represents
+ // 64.5us of added time beyond the 1.3ms fixed base period. The
+ // default is 48 units.
+ static const int averagingSamplePeriod = 48;
-protected:
// I2C interface to device
BitBangI2C i2c;
@@ -192,6 +188,15 @@
// current distance mode: 0=single shot, 1=continuous
bool distMode;
+
+ // range reading is in progress
+ bool rangeStarted;
+
+ // sample timer
+ Timer sampleTimer;
+
+ // time (from Timer t) of start of last range sample
+ uint32_t tSampleStart;
// read registers
uint8_t readReg8(uint16_t regAddr);
--- a/cfgVarMsgMap.h Fri Apr 21 18:50:37 2017 +0000
+++ b/cfgVarMsgMap.h Tue May 09 05:48:37 2017 +0000
@@ -48,7 +48,7 @@
// ********** DESCRIBE CONFIGURATION VARIABLES **********
case 0:
- v_byte_ro(19, 2); // number of SCALAR variables
+ v_byte_ro(21, 2); // number of SCALAR variables
v_byte_ro(6, 3); // number of ARRAY variables
break;
@@ -185,6 +185,18 @@
v_ui16(plunger.jitterWindow, 2);
break;
+ case 20:
+ // bar-code plunger setup
+ v_ui16(plunger.barCode.startPix, 2);
+ break;
+
+ case 21:
+ v_ui16(tlc59116.chipMask, 2);
+ v_byte(tlc59116.sda, 4);
+ v_byte(tlc59116.scl, 5);
+ v_byte(tlc59116.reset, 6);
+ break;
+
// case N: // new scalar variable
//
// !!! ATTENTION !!!
--- a/config.h Fri Apr 21 18:50:37 2017 +0000
+++ b/config.h Tue May 09 05:48:37 2017 +0000
@@ -1,49 +1,44 @@
// Pinscape Controller Configuration
//
-// New for 2016: dynamic configuration! To configure the controller,
-// connect the KL25Z to your PC, install the STANDARD pre-compiled .bin
-// file, and run the Windows config tool. There's no need (as there was in
-// the past) to edit the source code or to compile a custom version of the
-// binary just to customize setup options.
+// !!! ATTENTION !!!
+// If you've come here on advice in a forum to change a GPIO setting or
+// to #define a macro to enable the expansion boards, >>>STOP NOW<<<. The
+// advice you found is out of date and no longer applies. You don't need
+// to edit this file or recompile the firmware, and you shouldn't. Instead,
+// use the standard firmware, and set options using the Pinscape Config Tool
+// on your Windows PC. All options that were formerly configurable by
+// editing this file can be selected with the Config Tool. That's much
+// cleaner and easier than editing the source code, and it eliminates the
+// problem of re-synchronizing a private copy of the source code with future
+// updates. With the config tool, you only need the standard firmware build,
+// so future updates are a simple matter of downloading the latest version.
//
-// In earlier versions, configuration was handled mostly with #ifdef and
-// similar constructs. To customize the setup, you had to create a private
-// forked copy of the source code, edit the constants defined in config.h,
-// and compile a custom binary. That's no longer necessary!
//
-// The new approach is to do everything (or as much as possible, anyway)
-// via the Windows config tool. You shouldn't have to recompile a custom
-// version just to make a configurable change. Of course, you're still free
-// to create a custom version if you want to add entirely new features or
-// make changes that go beyond what the setup tool exposes.
+// IN THE PAST (but NOT NOW - see above), configuration was handled mostly
+// with #defines and #ifdefs. To customize the setup, you had to create a
+// private forked copy of the source code, edit the constants defined in
+// config.h, and compile a custom binary. That's no longer necessary because
+// the config tool lets you set all configurable options dynamically. Of
+// course, you're still free to create a custom version if you want to add
+// entirely new features or make changes that go beyond the configurable
+// options.
//
+#ifndef CONFIG_H
+#define CONFIG_H
-// Pre-packaged configuration selection.
+
+// TEST SETTINGS - FOR DEBUGGING PURPOSES ONLY. The macros below select
+// special option combinations for debugging purposes.
//
-// IMPORTANT! If you just want to create a custom configuration, DON'T
-// modify this file, DON'T use these macros, and DON'T compiler on mbed.
-// Instead, use the unmodified standard build and configure your system
-// using the Pinscape Config Tool on Windows. That's easier and better
-// because the config tool will be able to back up your settings to a
-// local file on your PC, and will automatically preserve your settings
-// across upgrades. You won't have to worry about merging your changes
-// into every update of the repository source code, since you'll never
-// have to change the source code.
-//
-// The different configurations here are purely for testing purposes.
-// The standard build uses the STANDARD_CONFIG settings, which are the
-// same as the original version where you had to modify config.h by hand
-// to customize your system.
-//
+// IMPORTANT! If you're trying to create a custom configuration because
+// you have a pin conflict or because you're using the expansion boards,
+// DON'T modify this file, DON'T use these macros, and DON'T recompile
+// the firmware. Use the Config Tool on your Windows PC instead.
#define STANDARD_CONFIG 1 // standard settings, based on v1 base settings
#define TEST_CONFIG_EXPAN 0 // configuration for the expansion boards
#define TEST_KEEP_PRINTF 0 // for debugging purposes, keep printf() enabled
// by leaving the SDA UART GPIO pins unallocated
-
-#ifndef CONFIG_H
-#define CONFIG_H
-
// Plunger type codes
// NOTE! These values are part of the external USB interface. New
// values can be added, but the meaning of an existing assigned number
@@ -143,6 +138,7 @@
const int PortType74HC595 = 4; // 74HC595 port
const int PortTypeVirtual = 5; // Virtual port - visible to host software, but not connected
// to a physical output
+const int PortTypeTLC59116 = 6; // TLC59116 port
// LedWiz output port flag bits
const uint8_t PortFlagActiveLow = 0x01; // physical output is active-low
@@ -156,10 +152,22 @@
struct LedWizPortCfg
{
uint8_t typ; // port type: a PortTypeXxx value
- uint8_t pin; // physical output pin: for a GPIO port, this is an index in the
- // USB-to-PinName mapping list; for a TLC5940 or 74HC595 port, it's
- // the output number, starting from 0 for OUT0 on the first chip in
- // the daisy chain. For inactive and virtual ports, it's unused.
+ uint8_t pin; // physical output pin:
+ //
+ // - for a GPIO port, this is an index in the
+ // USB-to-PinName mapping list
+ //
+ // - for a TLC5940 or 74HC595 port, it's the output
+ // number in the overall daisy chain, starting
+ // from 0 for OUT0 on the first chip in the chain
+ //
+ // - for a TLC59116, the high 4 bits are the chip
+ // address (the low 4 bits of the address only),
+ // and the low 4 bits are the output number on
+ // the chip
+ //
+ // - for inactive and virtual ports, this is unused
+ //
uint8_t flags; // flags: a combination of PortFlagXxx values
void set(uint8_t typ, uint8_t pin, uint8_t flags = 0)
@@ -331,6 +339,13 @@
hc595.latch = PINNAME_TO_WIRE(PTA12);
hc595.ena = PINNAME_TO_WIRE(PTD4);
+ // disable all TLC59116 chips by default
+ tlc59116.chipMask = 0;
+
+ // Default TLC59116 pin assignments
+ tlc59116.sda = PINNAME_TO_WIRE(PTC6);
+ tlc59116.scl = PINNAME_TO_WIRE(PTC5);
+ tlc59116.reset = PINNAME_TO_WIRE(PTC10);
// Default IR hardware pin assignments. On the expansion boards,
// the sensor is connected to PTA13, and the emitter LED is on PTC9.
@@ -618,6 +633,12 @@
// physical travel. Zero disables the jitter filter.
uint16_t jitterWindow;
+ // bar code sensor parameters
+ struct
+ {
+ uint16_t startPix; // starting pixel offset
+ } barCode;
+
// ZB LAUNCH BALL button setup.
//
// This configures the "ZB Launch Ball" feature in DOF, based on Zeb's (of
@@ -757,7 +778,7 @@
struct
{
// number of TLC5940NT chips connected in daisy chain
- int nchips;
+ uint8_t nchips;
// pin connections (wire pin IDs)
uint8_t sin; // Serial data - must connect to SPIO MOSI -> PTC6 or PTD2
@@ -774,7 +795,7 @@
struct
{
// number of 74HC595 chips attached in daisy chain
- int nchips;
+ uint8_t nchips;
// pin connections
uint8_t sin; // Serial data - use any GPIO pin
@@ -784,6 +805,21 @@
} hc595;
+ // --- TLC59116 PWM Controller Chip Setup --
+ struct
+ {
+ // Chip mask. Each bit represents an enabled chip at the
+ // corresponding 4-bit address (i.e., bit 1<<addr represents
+ // the chip at 'addr').
+ uint16_t chipMask;
+
+ // pin connections
+ uint8_t sda; // I2C SDA
+ uint8_t scl; // I2C SCL
+ uint8_t reset; // !RESET (hardware reset line, active low)
+
+ } tlc59116;
+
// --- IR Remote Control Hardware Setup ---
struct
--- a/main.cpp Fri Apr 21 18:50:37 2017 +0000
+++ b/main.cpp Tue May 09 05:48:37 2017 +0000
@@ -47,34 +47,48 @@
// have native support for this type of input; as with the nudge setup, you just
// have to set some options in VP to activate the plunger.
//
-// The Pinscape software supports optical sensors (the TAOS TSL1410R and TSL1412R
-// linear sensor arrays) as well as slide potentiometers. The specific equipment
-// that's supported, along with physical mounting and wiring details, can be found
-// in the Build Guide.
+// We support several sensor types:
//
-// Note that VP has built-in support for plunger devices like this one, but
-// some VP tables can't use it without some additional scripting work. The
-// Build Guide has advice on adjusting tables to add plunger support when
-// necessary.
+// - AEDR-8300-1K2 optical encoders. These are quadrature encoders with
+// reflective optical sensing and built-in lighting and optics. The sensor
+// is attached to the plunger so that it moves with the plunger, and slides
+// along a guide rail with a reflective pattern of regularly spaces bars
+// for the encoder to read. We read the plunger position by counting the
+// bars the sensor passes as it moves across the rail. This is the newest
+// option, and it's my current favorite because it's highly accurate,
+// precise, and fast, plus it's relatively inexpensive.
+//
+// - Slide potentiometers. There are slide potentioneters available with a
+// long enough travel distance (at least 85mm) to cover the plunger travel.
+// Attach the plunger to the potentiometer knob so that the moving the
+// plunger moves the pot knob. We sense the position by simply reading
+// the analog voltage on the pot brush. A pot with a "linear taper" (that
+// is, the resistance varies linearly with the position) is required.
+// This option is cheap, easy to set up, and works well.
//
-// For best results, the plunger sensor should be calibrated. The calibration
-// is stored in non-volatile memory on board the KL25Z, so it's only necessary
-// to do the calibration once, when you first install everything. (You might
-// also want to re-calibrate if you physically remove and reinstall the CCD
-// sensor or the mechanical plunger, since their alignment shift change slightly
-// when you put everything back together.) You can optionally install a
-// dedicated momentary switch or pushbutton to activate the calibration mode;
-// this is describe in the project documentation. If you don't want to bother
-// with the extra button, you can also trigger calibration using the Windows
-// setup software, which you can find on the Pinscape project page.
+// - VL6108X time-of-flight distance sensor. This is an optical distance
+// sensor that measures the distance to a nearby object (within about 10cm)
+// by measuring the travel time for reflected pulses of light. It's fairly
+// cheap and easy to set up, but I don't recommend it because it has very
+// low precision.
//
-// The calibration procedure is described in the project documentation. Briefly,
-// when you trigger calibration mode, the software will scan the CCD for about
-// 15 seconds, during which you should simply pull the physical plunger back
-// all the way, hold it for a moment, and then slowly return it to the rest
-// position. (DON'T just release it from the retracted position, since that
-// let it shoot forward too far. We want to measure the range from the park
-// position to the fully retracted position only.)
+// - TSL1410R/TSL1412R linear array optical sensors. These are large optical
+// sensors with the pixels arranged in a single row. The pixel arrays are
+// large enough on these to cover the travel distance of the plunger, so we
+// can set up the sensor near the plunger in such a way that the plunger
+// casts a shadow on the sensor. We detect the plunger position by finding
+// the edge of the sahdow in the image. The optics for this setup are very
+// simple since we don't need any lenses. This was the first sensor we
+// supported, and works very well, but unfortunately the sensor is difficult
+// to find now since it's been discontinued by the manufacturer.
+//
+// The v2 Build Guide has details on how to build and configure all of the
+// sensor options.
+//
+// Visual Pinball has built-in support for plunger devices like this one, but
+// some older VP tables (particularly for VP 9) can't use it without some
+// modifications to their scripting. The Build Guide has advice on how to
+// fix up VP tables to add plunger support when necessary.
//
// - Button input wiring. You can assign GPIO ports as inputs for physical
// pinball-style buttons, such as flipper buttons, a Start button, coin
@@ -107,28 +121,34 @@
// 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 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.
+// - Enhanced LedWiz emulation with TLC5940 and/or TLC59116 PWM controller chips.
+// You can attach external PWM chips for controlling device outputs, instead of
+// using (or in addition to) the on-board GPIO ports as described above. The
+// software can control a set of daisy-chained TLC5940 or TLC59116 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.
//
// 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.
+// built in to the boards.
+//
+// To accommodate the larger supply of ports possible with the external chips,
+// the controller software provides a custom, extended version of the LedWiz
+// protocol that can handle up to 128 ports. Legacy PC software designed only
+// for the original LedWiz obviously can't use the extended protocol, and thus
+// can't 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 backwards compatible, so old software that only knows about the original
+// LedWiz protocol will still work, with the limitation that it can only access
+// the first 32 ports. In addition, we provide a replacement LEDWIZ.DLL that
+// creates virtual LedWiz units representing additional ports beyond the first
+// 32. This allows legacy LedWiz client software to address all ports by
+// making them think that you have several physical LedWiz units installed.
//
// - Night Mode control for output devices. You can connect a switch or button
// to the controller to activate "Night Mode", which disables feedback devices
@@ -222,6 +242,7 @@
#include "FreescaleIAP.h"
#include "crc32.h"
#include "TLC5940.h"
+#include "TLC59116.h"
#include "74HC595.h"
#include "nvm.h"
#include "TinyDigitalIn.h"
@@ -237,6 +258,7 @@
#include "nullSensor.h"
#include "barCodeSensor.h"
#include "distanceSensor.h"
+#include "tsl14xxSensor.h"
#define DECL_EXTERNS
@@ -646,17 +668,26 @@
// about 50 GPIO pins. So if you want to do everything with GPIO ports,
// you have to ration pins among features.
//
-// To overcome some of these limitations, we also provide two types of
+// To overcome some of these limitations, we also support several external
// peripheral controllers that allow adding many more outputs, using only
-// a small number of GPIO pins to interface with the peripherals. First,
-// we support TLC5940 PWM controller chips. Each TLC5940 provides 16 ports
-// with full PWM, and multiple TLC5940 chips can be daisy-chained. The
-// chip only requires 5 GPIO pins for the interface, no matter how many
-// chips are in the chain, so it effectively converts 5 GPIO pins into
-// almost any number of PWM outputs. Second, we support 74HC595 chips.
-// These provide only digital outputs, but like the TLC5940 they can be
-// daisy-chained to provide almost unlimited outputs with a few GPIO pins
-// to control the whole chain.
+// a small number of GPIO pins to interface with the peripherals:
+//
+// - TLC5940 PWM controller chips. Each TLC5940 provides 16 ports with
+// 12-bit PWM, and multiple TLC5940 chips can be daisy-chained. The
+// chips connect via 5 GPIO pins, and since they're daisy-chainable,
+// one set of 5 pins can control any number of the chips. So this chip
+// effectively converts 5 GPIO pins into almost any number of PWM outputs.
+//
+// - TLC59116 PWM controller chips. These are similar to the TLC5940 but
+// a newer generation with an improved design. These use an I2C bus,
+// allowing up to 14 chips to be connected via 3 GPIO pins.
+//
+// - 74HC595 shift register chips. These provide 8 digital (on/off only)
+// outputs per chip. These need 4 GPIO pins, and like the other can be
+// daisy chained to add more outputs without using more GPIO pins. These
+// are advantageous for outputs that don't require PWM, since the data
+// transfer sizes are so much smaller. The expansion boards use these
+// for the chime board outputs.
//
// Direct GPIO output ports and peripheral controllers can be mixed and
// matched in one system. The assignment of pins to ports and the
@@ -735,7 +766,7 @@
// Gamma correction table for 8-bit input values
-static const uint8_t gamma[] = {
+static const uint8_t dof_to_gamma_8bit[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
@@ -761,7 +792,7 @@
{
public:
LwGammaOut(LwOut *o) : out(o) { }
- virtual void set(uint8_t val) { out->set(gamma[val]); }
+ virtual void set(uint8_t val) { out->set(dof_to_gamma_8bit[val]); }
private:
LwOut *out;
@@ -903,10 +934,55 @@
uint8_t prv;
};
-
-
+//
+// TLC59116 interface object
+//
+TLC59116 *tlc59116 = 0;
+void init_tlc59116(Config &cfg)
+{
+ // Create the interface if any chips are enabled
+ if (cfg.tlc59116.chipMask != 0)
+ {
+ // set up the interface
+ tlc59116 = new TLC59116(
+ wirePinName(cfg.tlc59116.sda),
+ wirePinName(cfg.tlc59116.scl),
+ wirePinName(cfg.tlc59116.reset));
+
+ // initialize the chips
+ tlc59116->init();
+ }
+}
+
+// LwOut class for TLC59116 outputs. The 'addr' value in the constructor
+// is low 4 bits of the chip's I2C address; this is the part of the address
+// that's configurable per chip. 'port' is the output number on the chip
+// (0-15).
+//
+// Note that we don't need a separate gamma-corrected subclass for this
+// output type, since there's no loss of precision with the standard layered
+// gamma (it emits 8-bit values, and we take 8-bit inputs).
+class Lw59116Out: public LwOut
+{
+public:
+ Lw59116Out(uint8_t addr, uint8_t port) : addr(addr), port(port) { prv = 0; }
+ virtual void set(uint8_t val)
+ {
+ if (val != prv)
+ tlc59116->set(addr, port, prv = val);
+ }
+
+protected:
+ uint8_t addr;
+ uint8_t port;
+ uint8_t prv;
+};
+
+
+//
// 74HC595 interface object. Set this up with the port assignments in
// config.h.
+//
HC595 *hc595 = 0;
// initialize the 74HC595 interface
@@ -1276,13 +1352,22 @@
break;
case PortType74HC595:
- // 74HC595 port (if we don't have an HC595 controller object, or it's not a valid
- // output number, create a virtual port)
+ // 74HC595 port (if we don't have an HC595 controller object, or it's not
+ // a valid output number, create a virtual port)
if (hc595 != 0 && pin < cfg.hc595.nchips*8)
lwp = new Lw595Out(pin);
else
lwp = new LwVirtualOut();
break;
+
+ case PortTypeTLC59116:
+ // TLC59116 port. The pin number in the config encodes the chip address
+ // in the high 4 bits and the output number on the chip in the low 4 bits.
+ // There's no gamma-corrected version of this output handler, so we don't
+ // need to worry about that here; just use the layered gamma as needed.
+ if (tlc59116 != 0)
+ lwp = new Lw59116Out((pin >> 4) & 0x0F, pin & 0x0F);
+ break;
case PortTypeVirtual:
case PortTypeDisabled:
@@ -3907,10 +3992,8 @@
else
{
// The latch didn't stick, so PSU2 was still off at
- // our last check. Try pulsing it again in case PSU2
- // was turned on since the last check.
- psu2_status_set->write(1);
- psu2_state = 2;
+ // our last check. Return to idle state.
+ psu2_state = 1;
}
break;
@@ -4197,6 +4280,8 @@
saveConfigSucceededFlag = 0x40;
// start the followup timer
+ saveConfigFollowupTime = tFollowup;
+ saveConfigFollowupTimer.reset();
saveConfigFollowupTimer.start();
// if a reboot is pending, flag it
@@ -4336,10 +4421,10 @@
// the plunger sensor interface object
PlungerSensor *plungerSensor = 0;
-// wait for the plunger sensor to complete any outstanding read
+// wait for the plunger sensor to complete any outstanding DMA transfer
static void waitPlungerIdle(void)
{
- while (!plungerSensor->ready()) { }
+ while (plungerSensor->dmaBusy()) { }
}
// Create the plunger sensor based on the current configuration. If
@@ -4409,8 +4494,9 @@
break;
}
- // set the jitter filter
- plungerSensor->setJitterWindow(cfg.plunger.jitterWindow);
+ // initialize the config variables affecting the plunger
+ plungerSensor->onConfigChange(19, cfg);
+ plungerSensor->onConfigChange(20, cfg);
}
// Global plunger calibration mode flag
@@ -4473,9 +4559,6 @@
{
// not in a firing event yet
firing = 0;
-
- // no history yet
- histIdx = 0;
}
// Collect a reading from the plunger sensor. The main loop calls
@@ -4492,25 +4575,6 @@
PlungerReading r;
if (plungerSensor->read(r))
{
- // Pull the previous reading from the history
- const PlungerReading &prv = nthHist(0);
-
- // If the new reading is within 1ms of the previous reading,
- // ignore it. We require a minimum time between samples to
- // ensure that we have a usable amount of precision in the
- // denominator (the time interval) for calculating the plunger
- // velocity. The CCD sensor hardware takes about 2.5ms to
- // read, so it will never be affected by this, but other sensor
- // types don't all have the same hardware cycle time, so we need
- // to throttle them artificially. E.g., the potentiometer only
- // needs one ADC sample per reading, which only takes about 15us;
- // the quadrature sensor needs no time at all since it keeps
- // track of the position continuously via interrupts. We don't
- // need to check which sensor type we have here; we just ignore
- // readings until the minimum interval has passed.
- if (uint32_t(r.t - prv.t) < 1000UL)
- return;
-
// check for calibration mode
if (plungerCalMode)
{
@@ -4575,98 +4639,130 @@
r.pos = -JOYMAX;
}
- // Calculate the velocity from the second-to-last reading
- // to here, in joystick distance units per microsecond.
- // Note that we use the second-to-last reading rather than
- // the very last reading to give ourselves a little longer
- // time base. The time base is so short between consecutive
- // readings that the error bars in the position would be too
- // large.
+ // Look for a firing event - the user releasing the plunger and
+ // allowing it to shoot forward at full speed. Wait at least 5ms
+ // between samples for this, to help distinguish random motion
+ // from the rapid motion of a firing event.
//
- // For reference, the physical plunger velocity ranges up
- // to about 100,000 joystick distance units/sec. This is
- // based on empirical measurements. The typical time for
- // a real plunger to travel the full distance when released
- // from full retraction is about 85ms, so the average velocity
- // covering this distance is about 56,000 units/sec. The
- // peak is probably about twice that. In real-world units,
- // this translates to an average speed of about .75 m/s and
- // a peak of about 1.5 m/s.
+ // There's a trade-off in the choice of minimum sampling interval.
+ // The longer we wait, the more certain we can be of the trend.
+ // But if we wait too long, the user will perceive a delay. We
+ // also want to sample frequently enough to see the release motion
+ // at intermediate steps along the way, so the sampling has to be
+ // considerably faster than the whole travel time, which is about
+ // 25-50ms.
+ if (uint32_t(r.t - prv.t) < 5000UL)
+ return;
+
+ // assume that we'll report this reading as-is
+ z = r.pos;
+
+ // Firing event detection.
+ //
+ // A "firing event" is when the player releases the plunger from
+ // a retracted position, allowing it to shoot forward under the
+ // spring tension.
//
- // Note that we actually calculate the value here in units
- // per *microsecond* - the discussion above is in terms of
- // units/sec because that's more on a human scale. Our
- // choice of internal units here really isn't important,
- // since we only use the velocity for comparison purposes,
- // to detect acceleration trends. We therefore save ourselves
- // a little CPU time by using the natural units of our inputs.
+ // We monitor the plunger motion for these events, and when they
+ // occur, we report an "idealized" version of the motion to the
+ // PC. The idealized version consists of a series of readings
+ // frozen at the fully retracted position for the whole duration
+ // of the forward travel, followed by a series of readings at the
+ // fully forward position for long enough for the plunger to come
+ // mostly to rest. The series of frozen readings aren't meant to
+ // be perceptible to the player - we try to keep them short enough
+ // that they're not apparent as delay. Instead, they're for the
+ // PC client software's benefit. PC joystick clients use polling,
+ // so they only see an unpredictable subset of the readings we
+ // send. The only way to be sure that the client sees a particular
+ // reading is to hold it for long enough that the client is sure to
+ // poll within the hold interval. In the case of the plunger
+ // firing motion, it's important that the client sees the *ends*
+ // of the travel - the fully retracted starting position in
+ // particular. If the PC client only polls for a sample while the
+ // plunger is somewhere in the middle of the travel, the PC will
+ // think that the firing motion *started* in that middle position,
+ // so it won't be able to model the right amount of momentum when
+ // the plunger hits the ball. We try to ensure that the PC sees
+ // the right starting point by reporting the starting point for
+ // extra time during the forward motion. By the same token, we
+ // want the PC to know that the plunger has moved all the way
+ // forward, rather than mistakenly thinking that it stopped
+ // somewhere in the middle of the travel, so we freeze at the
+ // forward position for a short time.
//
- // We don't care about the absolute velocity; this is a purely
- // relative calculation. So to speed things up, calculate it
- // in the integer domain, using a fixed-point representation
- // with a 64K scale. In other words, with the stored values
- // shifted left 16 bits from the actual values: the value 1
- // is stored as 1<<16. The position readings are in the range
- // -JOYMAX..JOYMAX, which fits in 16 bits, and the time
- // differences will generally be on the scale of a few
- // milliseconds = thousands of microseconds. So the velocity
- // figures will fit nicely into a 32-bit fixed point value with
- // a 64K scale factor.
- const PlungerReading &prv2 = nthHist(1);
- int v = ((r.pos - prv2.pos) * 65536L)/int(r.t - prv2.t);
-
- // presume we'll report the latest instantaneous reading
- z = r.pos;
-
- // Check firing events
+ // To detect a firing event, we look for forward motion that's
+ // fast enough to be a firing event. To determine how fast is
+ // fast enough, we use a simple model of the plunger motion where
+ // the acceleration is constant. This is only an approximation,
+ // as the spring force actually varies with spring's compression,
+ // but it's close enough for our purposes here.
+ //
+ // Do calculations in fixed-point 2^48 scale with 64-bit ints.
+ // acc2 = acceleration/2 for 50ms release time, units of unit
+ // distances per microsecond squared, where the unit distance
+ // is the overall travel from the starting retracted position
+ // to the park position.
+ const int32_t acc2 = 112590; // 2^48 scale
switch (firing)
{
case 0:
- // Default state - not in a firing event.
-
- // If we have forward motion from a position that's retracted
- // beyond a threshold, enter phase 1. If we're not pulled back
- // far enough, don't bother with this, as a release wouldn't
- // be strong enough to require the synthetic firing treatment.
- if (v < 0 && r.pos > JOYMAX/6)
+ // Not in firing mode. If we're retracted a bit, and the
+ // motion is forward at a fast enough rate to look like a
+ // release, enter firing mode.
+ if (r.pos > JOYMAX/6)
{
- // 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;
-
- // Figure the barrel spring "bounce" position in case we complete
- // the firing event. This is the amount that the forward momentum
- // of the plunger will compress the barrel spring at the peak of
- // the forward travel during the release. Assume that this is
- // 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 not very accurate, but it seems to give good
- // visual results, and that's all it's for.)
- f2.pos = -r.pos/6;
+ const uint32_t dt = uint32_t(r.t - prv.t);
+ const uint32_t dt2 = dt*dt; // dt^2
+ if (r.pos < prv.pos - int((prv.pos*acc2*uint64_t(dt2)) >> 48))
+ {
+ // Tentatively enter firing mode. Use the prior reading
+ // as the starting point, and freeze reports for now.
+ firingMode(1);
+ f0 = prv;
+ z = f0.pos;
+
+ // if in calibration state 1 (at rest), switch to
+ // state 2 (not at rest)
+ if (calState == 1)
+ calState = 2;
+ }
}
break;
case 1:
- // Phase 1 - acceleration. If we cross the zero point, trigger
- // the firing event. Otherwise, continue monitoring as long as we
- // see acceleration in the forward direction.
+ // Tentative firing mode: the plunger was moving forward
+ // at last check. To stay in firing mode, the plunger has
+ // to keep moving forward fast enough to look like it's
+ // moving under spring force. To figure out how fast is
+ // fast enough, we use a simple model where the acceleration
+ // is constant over the whole travel distance and the total
+ // travel time is 50ms. The acceleration actually varies
+ // slightly since it comes from the spring force, which
+ // is linear in the displacement; but the plunger spring is
+ // fairly compressed even when the plunger is all the way
+ // forward, so the difference in tension from one end of
+ // the travel to the other is fairly small, so it's not too
+ // far off to model it as constant. And the real travel
+ // time obviously isn't a constant, but all we need for
+ // that is an upper bound. So: we'll figure the time since
+ // we entered firing mode, and figure the distance we should
+ // have traveled to complete the trip within the maximum
+ // time allowed. If we've moved far enough, we'll stay
+ // in firing mode; if not, we'll exit firing mode. And if
+ // we cross the finish line while still in firing mode,
+ // we'll switch to the next phase of the firing event.
if (r.pos <= 0)
{
- // switch to the synthetic firing mode
+ // We crossed the park position. Switch to the second
+ // phase of the firing event, where we hold the reported
+ // position at the "bounce" position (where the plunger
+ // is all the way forward, compressing the barrel spring).
+ // We'll stick here long enough to ensure that the PC
+ // client (Visual Pinball or whatever) sees the reading
+ // and processes the release motion via the simulated
+ // physics.
firingMode(2);
- z = f2.pos;
-
- // 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
@@ -4676,142 +4772,96 @@
// 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)
+ // collect average firing time statistics in millseconds,
+ // if it's in range (20 to 255 ms)
+ const int dt = uint32_t(r.t - f0.t)/1000UL;
+ if (dt >= 15 && dt <= 255)
{
calRlsTimeSum += dt;
calRlsTimeN += 1;
cfg.plunger.cal.tRelease = uint8_t(calRlsTimeSum / calRlsTimeN);
}
}
- }
- else if (v < vprv2)
- {
- // We're still accelerating, and we haven't crossed the zero
- // point yet - stay in phase 1. (Note that forward motion is
- // negative velocity, so accelerating means that the new
- // velocity is more negative than the previous one, which
- // is to say numerically less than - that's why the test
- // for acceleration is the seemingly backwards 'v < vprv'.)
-
- // If we've been accelerating for at least 20ms, we're probably
- // really doing a release. Jump back to the recent local
- // maximum where the release *really* started. This is always
- // a bit before we started seeing sustained accleration, because
- // the plunger motion for the first few milliseconds is too slow
- // for our sensor precision to reliably detect acceleration.
- if (f1.pos != 0)
- {
- // we have a reset point - freeze there
- z = f1.pos;
- }
- else if (uint32_t(r.t - f1.t) >= 20000UL)
- {
- // it's been long enough - set a reset point.
- f1.pos = z = histLocalMax(r.t, 50000UL);
- }
+
+ // Figure the "bounce" position as forward of the park
+ // position by 1/6 of the starting retraction distance.
+ // This simulates the momentum of the plunger compressing
+ // the barrel spring on the rebound. The barrel spring
+ // can compress by about 1/6 of the maximum retraction
+ // distance, so we'll simply treat its compression as
+ // proportional to the retraction. (It might be more
+ // realistic to use a slightly higher value here, maybe
+ // 1/4 or 1/3 or the retraction distance, capping it at
+ // a maximum of 1/6, because the real plunger probably
+ // compresses the barrel spring by 100% with less than
+ // 100% retraction. But that won't affect the physics
+ // meaningfully, just the animation, and the effect is
+ // small in any case.)
+ z = f0.pos = -f0.pos / 6;
+
+ // reset the starting time for this phase
+ f0.t = r.t;
}
else
{
- // We're not accelerating. Cancel the firing event.
- firingMode(0);
- calState = 1;
+ // check for motion since the start of the firing event
+ const uint32_t dt = uint32_t(r.t - f0.t);
+ const uint32_t dt2 = dt*dt; // dt^2
+ if (dt < 50000
+ && r.pos < f0.pos - int((f0.pos*acc2*uint64_t(dt2)) >> 48))
+ {
+ // It's moving fast enough to still be in a release
+ // motion. Continue reporting the start position, and
+ // stay in the first release phase.
+ z = f0.pos;
+ }
+ else
+ {
+ // It's not moving fast enough to be a release
+ // motion. Return to the default state.
+ firingMode(0);
+ calState = 1;
+ }
}
break;
case 2:
- // Phase 2 - start of synthetic firing event. Report the fake
- // bounce for 25ms. VP polls the joystick about every 10ms, so
- // this should be enough time to guarantee that VP sees this
- // report at least once.
- if (uint32_t(r.t - f2.t) < 25000UL)
+ // Firing mode, holding at forward compression position.
+ // Hold here for 25ms.
+ if (uint32_t(r.t - f0.t) < 25000)
{
- // report the bounce position
- z = f2.pos;
+ // stay here for now
+ z = f0.pos;
}
else
{
- // it's been long enough - switch to phase 3, where we
- // report the park position until the real plunger comes
- // to rest
+ // advance to the next phase, where we report the park
+ // position until the plunger comes to rest
firingMode(3);
z = 0;
-
- // set the start of the "stability window" to the rest position
- f3s.t = r.t;
- f3s.pos = 0;
-
- // set the start of the "retraction window" to the actual position
- f3r = r;
+
+ // remember when we started
+ f0.t = r.t;
}
break;
case 3:
- // Phase 3 - in synthetic firing event. Report the park position
- // until the plunger position stabilizes. Left to its own devices,
- // the plunger will usualy bounce off the barrel spring several
- // times before coming to rest, so we'll see oscillating motion
- // for a second or two. In the simplest case, we can aimply wait
- // for the plunger to stop moving for a short time. However, the
- // player might intervene by pulling the plunger back again, so
- // watch for that motion as well. If we're just bouncing freely,
- // we'll see the direction change frequently. If the player is
- // moving the plunger manually, the direction will be constant
- // for longer.
- if (v >= 0)
+ // Firing event, holding at park position. Stay here for
+ // a few moments so that the PC client can simulate the
+ // full release motion, then return to real readings.
+ if (uint32_t(r.t - f0.t) < 250000)
{
- // We're moving back (or standing still). If this has been
- // going on for a while, the user must have taken control.
- if (uint32_t(r.t - f3r.t) > 65000UL)
- {
- // user has taken control - cancel firing mode
- firingMode(0);
- break;
- }
+ // stay here a while longer
+ z = 0;
}
else
{
- // forward motion - reset retraction window
- f3r.t = r.t;
- }
-
- // 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 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) > 300000UL)
- {
- // we're done with the firing event
- firingMode(0);
- }
- else
- {
- // it's close to the last position but hasn't been
- // here long enough; stay in firing mode and continue
- // to report the park position
- z = 0;
- }
- }
- else
- {
- // It's not close enough to the last starting point, so use
- // this as a new starting point, and stay in firing mode.
- f3s = r;
- z = 0;
+ // it's been long enough - return to normal mode
+ firingMode(0);
}
break;
}
- // save the velocity reading for next time
- vprv2 = vprv;
- vprv = v;
-
// Check for auto-zeroing, if enabled
if ((cfg.plunger.autoZero.flags & PlungerAutoZeroEnabled) != 0)
{
@@ -4837,10 +4887,8 @@
}
}
- // add the new reading to the history
- hist[histIdx] = r;
- if (++histIdx >= countof(hist))
- histIdx = 0;
+ // this new reading becomes the previous reading for next time
+ prv = r;
}
}
@@ -4851,9 +4899,6 @@
return z;
}
- // get the timestamp of the current joystick report (microseconds)
- uint32_t getTimestamp() const { return nthHist(0).t; }
-
// Set calibration mode on or off
void setCalMode(bool f)
{
@@ -4942,6 +4987,12 @@
bool isFiring() { return firing == 3; }
private:
+ // current reported joystick reading
+ int z;
+
+ // previous reading
+ PlungerReading prv;
+
// Calibration state. During calibration mode, we watch for release
// events, to measure the time it takes to complete the release
// motion; and we watch for the plunger to come to reset after a
@@ -4978,105 +5029,21 @@
firing = m;
}
- // Find the most recent local maximum in the history data, up to
- // the given time limit.
- int histLocalMax(uint32_t tcur, uint32_t dt)
- {
- // start with the prior entry
- int idx = (histIdx == 0 ? countof(hist) : histIdx) - 1;
- int hi = hist[idx].pos;
-
- // scan backwards for a local maximum
- for (int n = countof(hist) - 1 ; n > 0 ; idx = (idx == 0 ? countof(hist) : idx) - 1)
- {
- // if this isn't within the time window, stop
- if (uint32_t(tcur - hist[idx].t) > dt)
- break;
-
- // if this isn't above the current hith, stop
- if (hist[idx].pos < hi)
- break;
-
- // this is the new high
- hi = hist[idx].pos;
- }
-
- // return the local maximum
- return hi;
- }
-
- // velocity at previous reading, and the one before that
- int vprv, vprv2;
-
- // Circular buffer of recent readings. We keep a short history
- // of readings to analyze during firing events. We can only identify
- // a firing event once it's somewhat under way, so we need a little
- // retrospective information to accurately determine after the fact
- // exactly when it started. We throttle our readings to no more
- // than one every 1ms, so we have at least N*1ms of history in this
- // array.
- PlungerReading hist[32];
- int histIdx;
-
- // get the nth history item (0=last, 1=2nd to last, etc)
- inline const PlungerReading &nthHist(int n) const
- {
- // histIdx-1 is the last written; go from there
- n = histIdx - 1 - n;
-
- // adjust for wrapping
- if (n < 0)
- n += countof(hist);
-
- // return the item
- return hist[n];
- }
-
// Firing event state.
//
- // 0 - Default state. We report the real instantaneous plunger
- // position to the joystick interface.
- //
- // 1 - Moving forward
+ // 0 - Default state: not in firing event. We report the true
+ // instantaneous plunger position to the joystick interface.
//
- // 2 - Accelerating
+ // 1 - Moving forward at release speed
//
- // 3 - Firing. We report the rest position for a minimum interval,
- // or until the real plunger comes to rest somewhere.
+ // 2 - Firing - reporting the bounce position
+ //
+ // 3 - Firing - reporting the park position
//
int firing;
- // Position/timestamp at start of firing phase 1. When we see a
- // sustained forward acceleration, we freeze joystick reports at
- // the recent local maximum, on the assumption that this was the
- // start of the release. If this is zero, it means that we're
- // monitoring accelerating motion but haven't seen it for long
- // enough yet to be confident that a release is in progress.
- PlungerReading f1;
-
- // Position/timestamp at start of firing phase 2. The position is
- // the fake "bounce" position we report during this phase, and the
- // timestamp tells us when the phase began so that we can end it
- // after enough time elapses.
- PlungerReading f2;
-
- // Position/timestamp of start of stability window during phase 3.
- // We use this to determine when the plunger comes to rest. We set
- // this at the beginning of phase 3, and then reset it when the
- // plunger moves too far from the last position.
- PlungerReading f3s;
-
- // Position/timestamp of start of retraction window during phase 3.
- // We use this to determine if the user is drawing the plunger back.
- // If we see retraction motion for more than about 65ms, we assume
- // that the user has taken over, because we should see forward
- // motion within this timeframe if the plunger is just bouncing
- // freely.
- PlungerReading f3r;
-
- // next Z value to report to the joystick interface (in joystick
- // distance units)
- int z;
+ // Starting position for current firing mode phase
+ PlungerReading f0;
};
// plunger reader singleton
@@ -5574,10 +5541,9 @@
// in a variable-dependent format.
configVarSet(data);
- // If updating the jitter window (variable 19), apply it immediately
- // to the plunger sensor object
- if (data[1] == 19)
- plungerSensor->setJitterWindow(cfg.plunger.jitterWindow);
+ // notify the plunger, so that it can update relevant variables
+ // dynamically
+ plungerSensor->onConfigChange(data[1], cfg);
}
else if (data[0] == 67)
{
@@ -5775,6 +5741,9 @@
// set up the TLC5940 interface, if these chips are present
init_tlc5940(cfg);
+ // initialize the TLC5916 interface, if these chips are present
+ init_tlc59116(cfg);
+
// set up 74HC595 interface, if these chips are present
init_hc595(cfg);
@@ -5787,7 +5756,7 @@
// start the TLC5940 refresh cycle clock
if (tlc5940 != 0)
tlc5940->start();
-
+
// Assume that nothing uses keyboard keys. We'll check for keyboard
// usage when initializing the various subsystems that can send keys
// (buttons, IR). If we find anything that does, we'll create the
@@ -5927,6 +5896,8 @@
tlc5940->enable(true);
if (hc595 != 0)
hc595->enable(true);
+ if (tlc59116 != 0)
+ tlc59116->enable(true);
// start the LedWiz flash cycle timer
wizCycleTimer.start();
@@ -5985,6 +5956,10 @@
// send TLC5940 data updates if applicable
if (tlc5940 != 0)
tlc5940->send();
+
+ // send TLC59116 data updates
+ if (tlc59116 != 0)
+ tlc59116->send();
// collect diagnostic statistics, checkpoint 1
IF_DIAG(mainLoopIterCheckpt[1] += mainLoopTimer.read_us();)
@@ -6255,6 +6230,8 @@
// the power first comes on.
if (tlc5940 != 0)
tlc5940->enable(false);
+ if (tlc59116 != 0)
+ tlc59116->enable(false);
if (hc595 != 0)
hc595->enable(false);
}
@@ -6263,7 +6240,7 @@
// if we have a reboot timer pending, check for completion
if (saveConfigFollowupTimer.isRunning()
- && saveConfigFollowupTimer.read() > saveConfigFollowupTime)
+ && saveConfigFollowupTimer.read_us() > saveConfigFollowupTime*1000000UL)
{
// if a reboot is pending, execute it now
if (saveConfigRebootPending)
@@ -6323,6 +6300,10 @@
// send TLC5940 data if necessary
if (tlc5940 != 0)
tlc5940->send();
+
+ // update TLC59116 outputs
+ if (tlc59116 != 0)
+ tlc59116->send();
// show a diagnostic flash every couple of seconds
if (diagTimer.read_us() > 2000000)
@@ -6364,10 +6345,9 @@
// Enable peripheral chips and update them with current output data
if (tlc5940 != 0)
- {
tlc5940->enable(true);
- tlc5940->update(true);
- }
+ if (tlc59116 != 0)
+ tlc59116->enable(true);
if (hc595 != 0)
{
hc595->enable(true);