Arnaud VALLEY
Mirror with some correction
Dependencies: mbed FastIO FastPWM USBDevice
Diff: main.cpp
- Revision:
- 98:4df3c0f7e707
- Parent:
- 96:68d5621ff49f
- Child:
- 99:8139b0c274f4
--- a/main.cpp Wed Feb 07 00:01:21 2018 +0000
+++ b/main.cpp Fri Mar 01 23:53:59 2019 +0000
@@ -869,7 +869,7 @@
virtual void set(uint8_t level)
{
- // remebmber the new nominal level set by the client
+ // remember the new nominal level set by the client
val = level;
// update the physical output according to our current timing state
@@ -1066,8 +1066,12 @@
// for the PWM duty cycle of the physical output.
uint8_t params;
+ // Full-power time mapping. This maps from the 4-bit (0..15) time value
+ // in the parameters to the number of microseconds.
+ static const uint32_t paramToTime_us[];
+
// Figure the initial full-power time in microseconds
- inline uint32_t fullPowerTime_us() const { return ((params >> 4) + 1)*50000; }
+ inline uint32_t fullPowerTime_us() const { return paramToTime_us[params >> 4]; }
// Figure the hold power PWM level (0-255)
inline uint8_t holdPower() const { return (params & 0x0F) * 17; }
@@ -1078,7 +1082,9 @@
static Timer timer;
// Flipper logic pending timer list. Whenever a flipper logic output
- // transitions from OFF to ON, tis timer
+ // transitions from OFF to ON, we add it to this list. We scan the
+ // list in our polling routine to find ports that have reached the
+ // expiration of their initial full-power intervals.
static LwFlipperLogicOut **pending;
static uint8_t nPending;
};
@@ -1087,6 +1093,271 @@
Timer LwFlipperLogicOut::timer;
LwFlipperLogicOut **LwFlipperLogicOut::pending;
uint8_t LwFlipperLogicOut::nPending;
+const uint32_t LwFlipperLogicOut::paramToTime_us[] = {
+ 1000,
+ 2000,
+ 5000,
+ 10000,
+ 20000,
+ 40000,
+ 80000,
+ 100000,
+ 150000,
+ 200000,
+ 300000,
+ 400000,
+ 500000,
+ 600000,
+ 700000,
+ 800000
+};
+
+// Minimum On Time output. This is a filter output that we layer on
+// a physical output to force the underlying output to stay on for a
+// minimum interval. This can be used for devices that need to be on
+// for a certain amount of time to trigger their full effect, such as
+// slower solenoids or contactors.
+class LwMinTimeOut: public LwOut
+{
+public:
+ // Set up the output. 'param' is the configuration parameter
+ // for the mininum time span.
+ LwMinTimeOut(LwOut *o, uint8_t param)
+ : out(o), param(param)
+ {
+ // initially OFF
+ state = 0;
+ }
+
+ virtual void set(uint8_t level)
+ {
+ // update the physical output according to our current timing state
+ switch (state)
+ {
+ case 0:
+ // We're currently off. If the new level is non-zero, switch
+ // to state 1 (initial minimum interval) and set the requested
+ // level. If the new level is zero, we're switching from off to
+ // off, so there's no change.
+ if (level != 0)
+ {
+ // switch to state 1 (initial minimum interval, port is
+ // logically on)
+ state = 1;
+
+ // set the requested output level
+ out->set(level);
+
+ // add myself to the pending timer list
+ pending[nPending++] = this;
+
+ // note the starting time
+ t0 = timer.read_us();
+ }
+ break;
+
+ case 1: // min ON interval, port on
+ case 2: // min ON interval, port off
+ // We're in the initial minimum ON interval. If the new power
+ // level is non-zero, pass it through to the physical port, since
+ // the client is allowed to change the power level during the
+ // initial ON interval - they just can't turn it off entirely.
+ // Set the state to 1 to indicate that the logical port is on.
+ //
+ // If the new level is zero, leave the underlying port at its
+ // current power level, since we're not allowed to turn it off
+ // during this period. Set the state to 2 to indicate that the
+ // logical port is off even though the physical port has to stay
+ // on for the remainder of the interval.
+ if (level != 0)
+ {
+ // client is leaving the port on - pass through the new
+ // power level and set state 1 (logically on)
+ out->set(level);
+ state = 1;
+ }
+ else
+ {
+ // Client is turning off the port - leave the underlying port
+ // on at its current level and set state 2 (logically off).
+ // When the minimum ON time expires, the polling routine will
+ // see that we're logically off and will pass that through to
+ // the underlying physical port. Until then, though, we have
+ // to leave the physical port on to satisfy the minimum ON
+ // time requirement.
+ state = 2;
+ }
+ break;
+
+ case 3:
+ // We're out of the minimum ON interval, so we can set any new
+ // level, including fully off. Pass the new power level through
+ // to the port.
+ out->set(level);
+
+ // if the port is now off, return to state 0 (OFF)
+ if (level == 0)
+ state = 0;
+ break;
+ }
+ }
+
+ // Class initialization
+ static void classInit(Config &cfg)
+ {
+ // Count the Minimum On Time outputs in the configuration. We
+ // need to allocate enough pending timer list space to accommodate
+ // all of these outputs.
+ int n = 0;
+ for (int i = 0 ; i < MAX_OUT_PORTS ; ++i)
+ {
+ // if this port is active and marked as Flipper Logic, count it
+ if (cfg.outPort[i].typ != PortTypeDisabled
+ && (cfg.outPort[i].flags & PortFlagMinOnTime) != 0)
+ ++n;
+ }
+
+ // allocate space for the pending timer list
+ pending = new LwMinTimeOut*[n];
+
+ // there's nothing in the pending list yet
+ nPending = 0;
+
+ // Start our shared timer. The epoch is arbitrary, since we only
+ // use it to figure elapsed times.
+ timer.start();
+ }
+
+ // Check for ports with pending timers. The main routine should
+ // call this on each iteration to process our state transitions.
+ static void poll()
+ {
+ // note the current time
+ uint32_t t = timer.read_us();
+
+ // go through the timer list
+ for (int i = 0 ; i < nPending ; )
+ {
+ // get the port
+ LwMinTimeOut *port = pending[i];
+
+ // assume we'll keep it
+ bool remove = false;
+
+ // check if we're in the minimum ON period for the port
+ if (port->state == 1 || port->state == 2)
+ {
+ // we are - check if the minimum ON time has elapsed
+ if (uint32_t(t - port->t0) > port->minOnTime_us())
+ {
+ // This port has completed its initial ON interval, so
+ // it advances to the next state.
+ if (port->state == 1)
+ {
+ // The port is logically on, so advance to state 3,
+ // "on past minimum initial time". The underlying
+ // port is already at its proper level, since we pass
+ // through non-zero power settings to the underlying
+ // port throughout the initial ON interval.
+ port->state = 3;
+ }
+ else
+ {
+ // The port was switched off by the client during the
+ // minimum ON period. We haven't passed the OFF state
+ // to the underlying port yet, because the port has to
+ // stay on throughout the minimum ON period. So turn
+ // the port off now.
+ port->out->set(0);
+
+ // return to state 0 (OFF)
+ port->state = 0;
+ }
+
+ // we're done with the timer
+ remove = true;
+ }
+ }
+
+ // if desired, remove the port from the timer list
+ if (remove)
+ {
+ // Remove the list entry by overwriting the slot with
+ // the last entry in the list.
+ pending[i] = pending[--nPending];
+
+ // Note that we don't increment the loop counter, since
+ // we now need to revisit this same slot.
+ }
+ else
+ {
+ // we're keeping this item; move on to the next one
+ ++i;
+ }
+ }
+ }
+
+protected:
+ // underlying physical output
+ LwOut *out;
+
+ // Timestamp on 'timer' of start of full-power interval. We set this
+ // to the current 'timer' timestamp when entering state 1.
+ uint32_t t0;
+
+ // Current port state:
+ //
+ // 0 = off
+ // 1 = initial minimum ON interval, logical port is ON
+ // 2 = initial minimum ON interval, logical port is OFF
+ // 3 = past the minimum ON interval
+ //
+ uint8_t state;
+
+ // Configuration parameter. This encodes the minimum ON time.
+ uint8_t param;
+
+ // Timer. This is a shared timer for all of the minimum ON time ports.
+ // When we transition from OFF to ON, we note the current time on this
+ // timer to establish the start of our minimum ON period.
+ static Timer timer;
+
+ // translaton table from timing parameter in config to minimum ON time
+ static const uint32_t paramToTime_us[];
+
+ // Figure the minimum ON time
+ inline uint32_t minOnTime_us() const { return paramToTime_us[param & 0x0F]; }
+
+ // Pending timer list. Whenever one of our ports transitions from OFF
+ // to ON, we add it to this list. We scan this list in our polling
+ // routine to find ports that have reached the ends of their initial
+ // ON intervals.
+ static LwMinTimeOut **pending;
+ static uint8_t nPending;
+};
+
+// Min Time Out statics
+Timer LwMinTimeOut::timer;
+LwMinTimeOut **LwMinTimeOut::pending;
+uint8_t LwMinTimeOut::nPending;
+const uint32_t LwMinTimeOut::paramToTime_us[] = {
+ 1000,
+ 2000,
+ 5000,
+ 10000,
+ 20000,
+ 40000,
+ 80000,
+ 100000,
+ 150000,
+ 200000,
+ 300000,
+ 400000,
+ 500000,
+ 600000,
+ 700000,
+ 800000
+};
//
// The TLC5940 interface object. We'll set this up with the port
@@ -1576,6 +1847,7 @@
int activeLow = flags & PortFlagActiveLow;
int gamma = flags & PortFlagGamma;
int flipperLogic = flags & PortFlagFlipperLogic;
+ int hasMinOnTime = flags & PortFlagMinOnTime;
// cancel gamma on flipper logic ports
if (flipperLogic)
@@ -1692,6 +1964,10 @@
if (flipperLogic)
lwp = new LwFlipperLogicOut(lwp, pc.flipperLogic);
+ // Layer on the Minimum On Time if desired
+ if (hasMinOnTime)
+ lwp = new LwMinTimeOut(lwp, pc.minOnTime);
+
// If it's a noisemaker, layer on a night mode switch
if (noisy)
lwp = new LwNoisyOut(lwp);
@@ -1720,8 +1996,9 @@
// initialize the output pin array
void initLwOut(Config &cfg)
{
- // Initialize the Flipper Logic outputs
+ // Initialize the Flipper Logic and Minimum On Time outputs
LwFlipperLogicOut::classInit(cfg);
+ LwMinTimeOut::classInit(cfg);
// Count the outputs. The first disabled output determines the
// total number of ports.
@@ -3271,7 +3548,18 @@
// assigned to the shifted or unshifted version of the
// button.
bool pressed;
- if ((cfg.nightMode.flags & 0x02) != 0)
+ if (shiftButton.index == i)
+ {
+ // This button is both the Shift button AND the Night
+ // Mode button. This is a special case in that the
+ // Shift status is irrelevant, because it's obviously
+ // identical to the Night Mode status. So it doesn't
+ // matter whether or not the Night Mode button has the
+ // shifted flags; the raw button state is all that
+ // counts in this case.
+ pressed = true;
+ }
+ else if ((cfg.nightMode.flags & 0x02) != 0)
{
// Shift bit is set - night mode is assigned to the
// shifted version of the button. This is a Night
@@ -5737,6 +6025,7 @@
true, // we support the new accelerometer settings
true, // we support the "flash write ok" status bit in joystick reports
true, // we support the configurable joystick report timing features
+ true, // we use the new flipper logic timing table
mallocBytesFree()); // remaining memory size
break;
@@ -6019,10 +6308,10 @@
// say hello to the debug console, in case it's connected
printf("\r\nPinscape Controller starting\r\n");
- // Set the default PWM period to 1ms. This will be used for PWM
- // channels on PWM units whose periods aren't changed explicitly,
- // so it'll apply to LW outputs assigned to GPIO pins. Note that
- // the KL25Z only allows the period to be set at the TPM unit
+ // Set the default PWM period to 0.5ms = 2 kHz. This will be used
+ // for PWM channels on PWM units whose periods aren't changed
+ // explicitly, so it'll apply to LW outputs assigned to GPIO pins.
+ // The KL25Z only allows the period to be set at the TPM unit
// level, not per channel, so all channels on a given unit will
// necessarily use the same frequency. We (currently) have two
// subsystems that need specific PWM frequencies: TLC5940NT (which
@@ -6320,8 +6609,9 @@
// update PWM outputs
pollPwmUpdates();
- // update Flipper Logic outputs
+ // update Flipper Logic and Min On Time outputs
LwFlipperLogicOut::poll();
+ LwMinTimeOut::poll();
// poll the accelerometer
accel.poll();
@@ -6690,8 +6980,9 @@
// try to recover the connection
js.recoverConnection();
- // update Flipper Logic outputs
+ // update Flipper Logic and Min Out Time outputs
LwFlipperLogicOut::poll();
+ LwMinTimeOut::poll();
// send TLC5940 data if necessary
if (tlc5940 != 0)