Mirror with some correction
Dependencies: mbed FastIO FastPWM USBDevice
main.cpp@116:7a67265d7c19, 2021-10-01 (annotated)
- Committer:
- arnoz
- Date:
- Fri Oct 01 08:19:46 2021 +0000
- Revision:
- 116:7a67265d7c19
- Parent:
- 114:c2410d2cfaf1
- Correct information regarding your last merge
Who changed what in which revision?
User | Revision | Line number | New contents of line |
---|---|---|---|
mjr | 111:42dc75fbe623 | 1 | /* Copyright 2014, 2021 M J Roberts, MIT License |
mjr | 5:a70c0bce770d | 2 | * |
mjr | 5:a70c0bce770d | 3 | * Permission is hereby granted, free of charge, to any person obtaining a copy of this software |
mjr | 5:a70c0bce770d | 4 | * and associated documentation files (the "Software"), to deal in the Software without |
mjr | 5:a70c0bce770d | 5 | * restriction, including without limitation the rights to use, copy, modify, merge, publish, |
mjr | 5:a70c0bce770d | 6 | * distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the |
mjr | 5:a70c0bce770d | 7 | * Software is furnished to do so, subject to the following conditions: |
mjr | 5:a70c0bce770d | 8 | * |
mjr | 5:a70c0bce770d | 9 | * The above copyright notice and this permission notice shall be included in all copies or |
mjr | 5:a70c0bce770d | 10 | * substantial portions of the Software. |
mjr | 5:a70c0bce770d | 11 | * |
mjr | 5:a70c0bce770d | 12 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING |
mjr | 99:8139b0c274f4 | 13 | * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
mjr | 5:a70c0bce770d | 14 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, |
mjr | 5:a70c0bce770d | 15 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
mjr | 5:a70c0bce770d | 16 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
mjr | 5:a70c0bce770d | 17 | */ |
mjr | 5:a70c0bce770d | 18 | |
mjr | 5:a70c0bce770d | 19 | // |
mjr | 35:e959ffba78fd | 20 | // The Pinscape Controller |
mjr | 35:e959ffba78fd | 21 | // A comprehensive input/output controller for virtual pinball machines |
mjr | 5:a70c0bce770d | 22 | // |
mjr | 48:058ace2aed1d | 23 | // This project implements an I/O controller for virtual pinball cabinets. The |
mjr | 48:058ace2aed1d | 24 | // controller's function is to connect Visual Pinball (and other Windows pinball |
mjr | 48:058ace2aed1d | 25 | // emulators) with physical devices in the cabinet: buttons, sensors, and |
mjr | 48:058ace2aed1d | 26 | // feedback devices that create visual or mechanical effects during play. |
mjr | 38:091e511ce8a0 | 27 | // |
mjr | 48:058ace2aed1d | 28 | // The controller can perform several different functions, which can be used |
mjr | 38:091e511ce8a0 | 29 | // individually or in any combination: |
mjr | 5:a70c0bce770d | 30 | // |
mjr | 38:091e511ce8a0 | 31 | // - Nudge sensing. This uses the KL25Z's on-board accelerometer to sense the |
mjr | 38:091e511ce8a0 | 32 | // motion of the cabinet when you nudge it. Visual Pinball and other pinball |
mjr | 38:091e511ce8a0 | 33 | // emulators on the PC have native handling for this type of input, so that |
mjr | 38:091e511ce8a0 | 34 | // physical nudges on the cabinet turn into simulated effects on the virtual |
mjr | 38:091e511ce8a0 | 35 | // ball. The KL25Z measures accelerations as analog readings and is quite |
mjr | 38:091e511ce8a0 | 36 | // sensitive, so the effect of a nudge on the simulation is proportional |
mjr | 38:091e511ce8a0 | 37 | // to the strength of the nudge. Accelerations are reported to the PC via a |
mjr | 38:091e511ce8a0 | 38 | // simulated joystick (using the X and Y axes); you just have to set some |
mjr | 38:091e511ce8a0 | 39 | // preferences in your pinball software to tell it that an accelerometer |
mjr | 38:091e511ce8a0 | 40 | // is attached. |
mjr | 5:a70c0bce770d | 41 | // |
mjr | 74:822a92bc11d2 | 42 | // - Plunger position sensing, with multiple sensor options. To use this feature, |
mjr | 35:e959ffba78fd | 43 | // you need to choose a sensor and set it up, connect the sensor electrically to |
mjr | 35:e959ffba78fd | 44 | // the KL25Z, and configure the Pinscape software on the KL25Z to let it know how |
mjr | 35:e959ffba78fd | 45 | // the sensor is hooked up. The Pinscape software monitors the sensor and sends |
mjr | 35:e959ffba78fd | 46 | // readings to Visual Pinball via the joystick Z axis. VP and other PC software |
mjr | 38:091e511ce8a0 | 47 | // have native support for this type of input; as with the nudge setup, you just |
mjr | 38:091e511ce8a0 | 48 | // have to set some options in VP to activate the plunger. |
mjr | 17:ab3cec0c8bf4 | 49 | // |
mjr | 87:8d35c74403af | 50 | // We support several sensor types: |
mjr | 35:e959ffba78fd | 51 | // |
mjr | 87:8d35c74403af | 52 | // - AEDR-8300-1K2 optical encoders. These are quadrature encoders with |
mjr | 87:8d35c74403af | 53 | // reflective optical sensing and built-in lighting and optics. The sensor |
mjr | 87:8d35c74403af | 54 | // is attached to the plunger so that it moves with the plunger, and slides |
mjr | 87:8d35c74403af | 55 | // along a guide rail with a reflective pattern of regularly spaces bars |
mjr | 87:8d35c74403af | 56 | // for the encoder to read. We read the plunger position by counting the |
mjr | 87:8d35c74403af | 57 | // bars the sensor passes as it moves across the rail. This is the newest |
mjr | 87:8d35c74403af | 58 | // option, and it's my current favorite because it's highly accurate, |
mjr | 87:8d35c74403af | 59 | // precise, and fast, plus it's relatively inexpensive. |
mjr | 87:8d35c74403af | 60 | // |
mjr | 87:8d35c74403af | 61 | // - Slide potentiometers. There are slide potentioneters available with a |
mjr | 87:8d35c74403af | 62 | // long enough travel distance (at least 85mm) to cover the plunger travel. |
mjr | 87:8d35c74403af | 63 | // Attach the plunger to the potentiometer knob so that the moving the |
mjr | 87:8d35c74403af | 64 | // plunger moves the pot knob. We sense the position by simply reading |
mjr | 87:8d35c74403af | 65 | // the analog voltage on the pot brush. A pot with a "linear taper" (that |
mjr | 87:8d35c74403af | 66 | // is, the resistance varies linearly with the position) is required. |
mjr | 87:8d35c74403af | 67 | // This option is cheap, easy to set up, and works well. |
mjr | 5:a70c0bce770d | 68 | // |
mjr | 111:42dc75fbe623 | 69 | // - TCD1103 optical linear imaging array. This is a CCD-based optical |
mjr | 111:42dc75fbe623 | 70 | // imaging sensor, essentially an optical camera sensor, with a linear |
mjr | 111:42dc75fbe623 | 71 | // (single-row) pixel file. This is similar to the venerable TSL1410R, |
mjr | 111:42dc75fbe623 | 72 | // the original Pinscape plunger sensor. By arranging the sensor's |
mjr | 111:42dc75fbe623 | 73 | // linear pixel array parallel to the plunger's axis of travel, we can |
mjr | 111:42dc75fbe623 | 74 | // use the sensor to take pictures of the plunger, and then analyze the |
mjr | 111:42dc75fbe623 | 75 | // images in software to determine the position by looking for the edge |
mjr | 111:42dc75fbe623 | 76 | // between the tip of the plunger and the background. The TCD1103 is |
mjr | 111:42dc75fbe623 | 77 | // produces low-noise images with 1500 pixels of resolution, and with |
mjr | 111:42dc75fbe623 | 78 | // a small focusing lens, the software can reliably determine the |
mjr | 111:42dc75fbe623 | 79 | // plunger position to a single pixel, which translates to about |
mjr | 111:42dc75fbe623 | 80 | // 1/400" precision. The sensor can take these images (and we can |
mjr | 111:42dc75fbe623 | 81 | // analyze them) at about 400 frames per second. Between the high |
mjr | 111:42dc75fbe623 | 82 | // spatial resolution and fast update rate, this is the best sensor |
mjr | 111:42dc75fbe623 | 83 | // I've found for this job. |
mjr | 111:42dc75fbe623 | 84 | // |
mjr | 111:42dc75fbe623 | 85 | // - VCNL4010 IR proximity sensor. This is an optical distance sensor that |
mjr | 111:42dc75fbe623 | 86 | // estimates the distance to a target by measuring the intensity of a |
mjr | 111:42dc75fbe623 | 87 | // reflected IR light signal that the sensor bounces off the target. |
mjr | 111:42dc75fbe623 | 88 | // This is the sensor that's used in the commercial VirtuaPin "v3" |
mjr | 111:42dc75fbe623 | 89 | // plunger kit. Since the VirtuaPin kit also uses a KL25Z as its |
mjr | 111:42dc75fbe623 | 90 | // microcontroller, some users of that product have asked for support |
mjr | 111:42dc75fbe623 | 91 | // for this sensor in the Pinscape code, so that they have the option |
mjr | 111:42dc75fbe623 | 92 | // to use their hardware from that kit with the Pinscape software. |
mjr | 111:42dc75fbe623 | 93 | // IR proximity sensors aren't very accurate or precise, so I don't |
mjr | 111:42dc75fbe623 | 94 | // recommend it to people setting up a new system from scratch - it's |
mjr | 111:42dc75fbe623 | 95 | // mostly for people who already have the VirtuaPin kit and don't want |
mjr | 111:42dc75fbe623 | 96 | // to change their hardware to migrate to Pinscape. However, Adafruit |
mjr | 111:42dc75fbe623 | 97 | // makes a breakout board for the sensor that you can use to set up a |
mjr | 111:42dc75fbe623 | 98 | // new system if you want to try it - it only requires a few wires to |
mjr | 111:42dc75fbe623 | 99 | // connect to the KL25Z. (In fact, it appears that VirtuaPin buys the |
mjr | 111:42dc75fbe623 | 100 | // Adafruit breakout board and repackages it for their kit, so you'll |
mjr | 111:42dc75fbe623 | 101 | // be using the same thing that VirtuaPin customers have.) |
mjr | 111:42dc75fbe623 | 102 | // |
mjr | 87:8d35c74403af | 103 | // - VL6108X time-of-flight distance sensor. This is an optical distance |
mjr | 87:8d35c74403af | 104 | // sensor that measures the distance to a nearby object (within about 10cm) |
mjr | 87:8d35c74403af | 105 | // by measuring the travel time for reflected pulses of light. It's fairly |
mjr | 87:8d35c74403af | 106 | // cheap and easy to set up, but I don't recommend it because it has very |
mjr | 87:8d35c74403af | 107 | // low precision. |
mjr | 6:cc35eb643e8f | 108 | // |
mjr | 87:8d35c74403af | 109 | // - TSL1410R/TSL1412R linear array optical sensors. These are large optical |
mjr | 87:8d35c74403af | 110 | // sensors with the pixels arranged in a single row. The pixel arrays are |
mjr | 87:8d35c74403af | 111 | // large enough on these to cover the travel distance of the plunger, so we |
mjr | 87:8d35c74403af | 112 | // can set up the sensor near the plunger in such a way that the plunger |
mjr | 87:8d35c74403af | 113 | // casts a shadow on the sensor. We detect the plunger position by finding |
mjr | 87:8d35c74403af | 114 | // the edge of the sahdow in the image. The optics for this setup are very |
mjr | 87:8d35c74403af | 115 | // simple since we don't need any lenses. This was the first sensor we |
mjr | 87:8d35c74403af | 116 | // supported, and works very well, but unfortunately the sensor is difficult |
mjr | 111:42dc75fbe623 | 117 | // to find now since it's been discontinued by the manufacturer. Happily, |
mjr | 111:42dc75fbe623 | 118 | // a good alternative is available: the Toshiba TCD1103, which is another |
mjr | 111:42dc75fbe623 | 119 | // linear imaging sensor that works on a similar principle, but produces |
mjr | 111:42dc75fbe623 | 120 | // even better results. |
mjr | 87:8d35c74403af | 121 | // |
mjr | 87:8d35c74403af | 122 | // The v2 Build Guide has details on how to build and configure all of the |
mjr | 87:8d35c74403af | 123 | // sensor options. |
mjr | 87:8d35c74403af | 124 | // |
mjr | 87:8d35c74403af | 125 | // Visual Pinball has built-in support for plunger devices like this one, but |
mjr | 87:8d35c74403af | 126 | // some older VP tables (particularly for VP 9) can't use it without some |
mjr | 87:8d35c74403af | 127 | // modifications to their scripting. The Build Guide has advice on how to |
mjr | 87:8d35c74403af | 128 | // fix up VP tables to add plunger support when necessary. |
mjr | 5:a70c0bce770d | 129 | // |
mjr | 77:0b96f6867312 | 130 | // - Button input wiring. You can assign GPIO ports as inputs for physical |
mjr | 77:0b96f6867312 | 131 | // pinball-style buttons, such as flipper buttons, a Start button, coin |
mjr | 77:0b96f6867312 | 132 | // chute switches, tilt bobs, and service panel buttons. You can configure |
mjr | 77:0b96f6867312 | 133 | // each button input to report a keyboard key or joystick button press to |
mjr | 77:0b96f6867312 | 134 | // the PC when the physical button is pushed. |
mjr | 13:72dda449c3c0 | 135 | // |
mjr | 53:9b2611964afc | 136 | // - LedWiz emulation. The KL25Z can pretend to be an LedWiz device. This lets |
mjr | 53:9b2611964afc | 137 | // you connect feedback devices (lights, solenoids, motors) to GPIO ports on the |
mjr | 53:9b2611964afc | 138 | // KL25Z, and lets PC software (such as Visual Pinball) control them during game |
mjr | 53:9b2611964afc | 139 | // play to create a more immersive playing experience. The Pinscape software |
mjr | 53:9b2611964afc | 140 | // presents itself to the host as an LedWiz device and accepts the full LedWiz |
mjr | 53:9b2611964afc | 141 | // command set, so software on the PC designed for real LedWiz'es can control |
mjr | 53:9b2611964afc | 142 | // attached devices without any modifications. |
mjr | 5:a70c0bce770d | 143 | // |
mjr | 53:9b2611964afc | 144 | // Even though the software provides a very thorough LedWiz emulation, the KL25Z |
mjr | 53:9b2611964afc | 145 | // GPIO hardware design imposes some serious limitations. The big one is that |
mjr | 53:9b2611964afc | 146 | // the KL25Z only has 10 PWM channels, meaning that only 10 ports can have |
mjr | 53:9b2611964afc | 147 | // varying-intensity outputs (e.g., for controlling the brightness level of an |
mjr | 53:9b2611964afc | 148 | // LED or the speed or a motor). You can control more than 10 output ports, but |
mjr | 53:9b2611964afc | 149 | // only 10 can have PWM control; the rest are simple "digital" ports that can only |
mjr | 53:9b2611964afc | 150 | // be switched fully on or fully off. The second limitation is that the KL25Z |
mjr | 53:9b2611964afc | 151 | // just doesn't have that many GPIO ports overall. There are enough to populate |
mjr | 53:9b2611964afc | 152 | // all 32 button inputs OR all 32 LedWiz outputs, but not both. The default is |
mjr | 53:9b2611964afc | 153 | // to assign 24 buttons and 22 LedWiz ports; you can change this balance to trade |
mjr | 53:9b2611964afc | 154 | // off more outputs for fewer inputs, or vice versa. The third limitation is that |
mjr | 53:9b2611964afc | 155 | // the KL25Z GPIO pins have *very* tiny amperage limits - just 4mA, which isn't |
mjr | 53:9b2611964afc | 156 | // even enough to control a small LED. So in order to connect any kind of feedback |
mjr | 53:9b2611964afc | 157 | // device to an output, you *must* build some external circuitry to boost the |
mjr | 53:9b2611964afc | 158 | // current handing. The Build Guide has a reference circuit design for this |
mjr | 53:9b2611964afc | 159 | // purpose that's simple and inexpensive to build. |
mjr | 6:cc35eb643e8f | 160 | // |
mjr | 87:8d35c74403af | 161 | // - Enhanced LedWiz emulation with TLC5940 and/or TLC59116 PWM controller chips. |
mjr | 87:8d35c74403af | 162 | // You can attach external PWM chips for controlling device outputs, instead of |
mjr | 87:8d35c74403af | 163 | // using (or in addition to) the on-board GPIO ports as described above. The |
mjr | 87:8d35c74403af | 164 | // software can control a set of daisy-chained TLC5940 or TLC59116 chips. Each |
mjr | 87:8d35c74403af | 165 | // chip provides 16 PWM outputs, so you just need two of them to get the full |
mjr | 87:8d35c74403af | 166 | // complement of 32 output ports of a real LedWiz. You can hook up even more, |
mjr | 87:8d35c74403af | 167 | // though. Four chips gives you 64 ports, which should be plenty for nearly any |
mjr | 87:8d35c74403af | 168 | // virtual pinball project. |
mjr | 53:9b2611964afc | 169 | // |
mjr | 53:9b2611964afc | 170 | // The Pinscape Expansion Board project (which appeared in early 2016) provides |
mjr | 53:9b2611964afc | 171 | // a reference hardware design, with EAGLE circuit board layouts, that takes full |
mjr | 53:9b2611964afc | 172 | // advantage of the TLC5940 capability. It lets you create a customized set of |
mjr | 53:9b2611964afc | 173 | // outputs with full PWM control and power handling for high-current devices |
mjr | 87:8d35c74403af | 174 | // built in to the boards. |
mjr | 87:8d35c74403af | 175 | // |
mjr | 87:8d35c74403af | 176 | // To accommodate the larger supply of ports possible with the external chips, |
mjr | 87:8d35c74403af | 177 | // the controller software provides a custom, extended version of the LedWiz |
mjr | 87:8d35c74403af | 178 | // protocol that can handle up to 128 ports. Legacy PC software designed only |
mjr | 87:8d35c74403af | 179 | // for the original LedWiz obviously can't use the extended protocol, and thus |
mjr | 87:8d35c74403af | 180 | // can't take advantage of its extra capabilities, but the latest version of |
mjr | 87:8d35c74403af | 181 | // DOF (DirectOutput Framework) *does* know the new language and can take full |
mjr | 87:8d35c74403af | 182 | // advantage. Older software will still work, though - the new extensions are |
mjr | 87:8d35c74403af | 183 | // all backwards compatible, so old software that only knows about the original |
mjr | 87:8d35c74403af | 184 | // LedWiz protocol will still work, with the limitation that it can only access |
mjr | 87:8d35c74403af | 185 | // the first 32 ports. In addition, we provide a replacement LEDWIZ.DLL that |
mjr | 87:8d35c74403af | 186 | // creates virtual LedWiz units representing additional ports beyond the first |
mjr | 87:8d35c74403af | 187 | // 32. This allows legacy LedWiz client software to address all ports by |
mjr | 87:8d35c74403af | 188 | // making them think that you have several physical LedWiz units installed. |
mjr | 26:cb71c4af2912 | 189 | // |
mjr | 38:091e511ce8a0 | 190 | // - Night Mode control for output devices. You can connect a switch or button |
mjr | 38:091e511ce8a0 | 191 | // to the controller to activate "Night Mode", which disables feedback devices |
mjr | 38:091e511ce8a0 | 192 | // that you designate as noisy. You can designate outputs individually as being |
mjr | 38:091e511ce8a0 | 193 | // included in this set or not. This is useful if you want to play a game on |
mjr | 38:091e511ce8a0 | 194 | // your cabinet late at night without waking the kids and annoying the neighbors. |
mjr | 38:091e511ce8a0 | 195 | // |
mjr | 38:091e511ce8a0 | 196 | // - TV ON switch. The controller can pulse a relay to turn on your TVs after |
mjr | 38:091e511ce8a0 | 197 | // power to the cabinet comes on, with a configurable delay timer. This feature |
mjr | 38:091e511ce8a0 | 198 | // is for TVs that don't turn themselves on automatically when first plugged in. |
mjr | 38:091e511ce8a0 | 199 | // To use this feature, you have to build some external circuitry to allow the |
mjr | 77:0b96f6867312 | 200 | // software to sense the power supply status. The Build Guide has details |
mjr | 77:0b96f6867312 | 201 | // on the necessary circuitry. You can use this to switch your TV on via a |
mjr | 77:0b96f6867312 | 202 | // hardwired connection to the TV's "on" button, which requires taking the |
mjr | 77:0b96f6867312 | 203 | // TV apart to gain access to its internal wiring, or optionally via the IR |
mjr | 77:0b96f6867312 | 204 | // remote control transmitter feature below. |
mjr | 77:0b96f6867312 | 205 | // |
mjr | 77:0b96f6867312 | 206 | // - Infrared (IR) remote control receiver and transmitter. You can attach an |
mjr | 77:0b96f6867312 | 207 | // IR LED and/or an IR sensor (we recommend the TSOP384xx series) to make the |
mjr | 77:0b96f6867312 | 208 | // KL25Z capable of sending and/or receiving IR remote control signals. This |
mjr | 77:0b96f6867312 | 209 | // can be used with the TV ON feature above to turn your TV(s) on when the |
mjr | 77:0b96f6867312 | 210 | // system power comes on by sending the "on" command to them via IR, as though |
mjr | 77:0b96f6867312 | 211 | // you pressed the "on" button on the remote control. The sensor lets the |
mjr | 77:0b96f6867312 | 212 | // Pinscape software learn the IR codes from your existing remotes, in the |
mjr | 77:0b96f6867312 | 213 | // same manner as a handheld universal remote control, and the IR LED lets |
mjr | 77:0b96f6867312 | 214 | // it transmit learned codes. The sensor can also be used to receive codes |
mjr | 77:0b96f6867312 | 215 | // during normal operation and turn them into PC keystrokes; this lets you |
mjr | 77:0b96f6867312 | 216 | // access extra commands on the PC without adding more buttons to your |
mjr | 77:0b96f6867312 | 217 | // cabinet. The IR LED can also be used to transmit other codes when you |
mjr | 77:0b96f6867312 | 218 | // press selected cabinet buttons, allowing you to assign cabinet buttons |
mjr | 77:0b96f6867312 | 219 | // to send IR commands to your cabinet TV or other devices. |
mjr | 38:091e511ce8a0 | 220 | // |
mjr | 35:e959ffba78fd | 221 | // |
mjr | 35:e959ffba78fd | 222 | // |
mjr | 33:d832bcab089e | 223 | // STATUS LIGHTS: The on-board LED on the KL25Z flashes to indicate the current |
mjr | 33:d832bcab089e | 224 | // device status. The flash patterns are: |
mjr | 6:cc35eb643e8f | 225 | // |
mjr | 48:058ace2aed1d | 226 | // short yellow flash = waiting to connect |
mjr | 6:cc35eb643e8f | 227 | // |
mjr | 48:058ace2aed1d | 228 | // short red flash = the connection is suspended (the host is in sleep |
mjr | 48:058ace2aed1d | 229 | // or suspend mode, the USB cable is unplugged after a connection |
mjr | 48:058ace2aed1d | 230 | // has been established) |
mjr | 48:058ace2aed1d | 231 | // |
mjr | 48:058ace2aed1d | 232 | // two short red flashes = connection lost (the device should immediately |
mjr | 48:058ace2aed1d | 233 | // go back to short-yellow "waiting to reconnect" mode when a connection |
mjr | 48:058ace2aed1d | 234 | // is lost, so this display shouldn't normally appear) |
mjr | 6:cc35eb643e8f | 235 | // |
mjr | 38:091e511ce8a0 | 236 | // long red/yellow = USB connection problem. The device still has a USB |
mjr | 48:058ace2aed1d | 237 | // connection to the host (or so it appears to the device), but data |
mjr | 48:058ace2aed1d | 238 | // transmissions are failing. |
mjr | 38:091e511ce8a0 | 239 | // |
mjr | 73:4e8ce0b18915 | 240 | // medium blue flash = TV ON delay timer running. This means that the |
mjr | 73:4e8ce0b18915 | 241 | // power to the secondary PSU has just been turned on, and the TV ON |
mjr | 73:4e8ce0b18915 | 242 | // timer is waiting for the configured delay time before pulsing the |
mjr | 73:4e8ce0b18915 | 243 | // TV power button relay. This is only shown if the TV ON feature is |
mjr | 73:4e8ce0b18915 | 244 | // enabled. |
mjr | 73:4e8ce0b18915 | 245 | // |
mjr | 6:cc35eb643e8f | 246 | // long yellow/green = everything's working, but the plunger hasn't |
mjr | 38:091e511ce8a0 | 247 | // been calibrated. Follow the calibration procedure described in |
mjr | 38:091e511ce8a0 | 248 | // the project documentation. This flash mode won't appear if there's |
mjr | 38:091e511ce8a0 | 249 | // no plunger sensor configured. |
mjr | 6:cc35eb643e8f | 250 | // |
mjr | 38:091e511ce8a0 | 251 | // alternating blue/green = everything's working normally, and plunger |
mjr | 38:091e511ce8a0 | 252 | // calibration has been completed (or there's no plunger attached) |
mjr | 10:976666ffa4ef | 253 | // |
mjr | 48:058ace2aed1d | 254 | // fast red/purple = out of memory. The controller halts and displays |
mjr | 48:058ace2aed1d | 255 | // this diagnostic code until you manually reset it. If this happens, |
mjr | 48:058ace2aed1d | 256 | // it's probably because the configuration is too complex, in which |
mjr | 48:058ace2aed1d | 257 | // case the same error will occur after the reset. If it's stuck |
mjr | 48:058ace2aed1d | 258 | // in this cycle, you'll have to restore the default configuration |
mjr | 48:058ace2aed1d | 259 | // by re-installing the controller software (the Pinscape .bin file). |
mjr | 10:976666ffa4ef | 260 | // |
mjr | 48:058ace2aed1d | 261 | // |
mjr | 48:058ace2aed1d | 262 | // USB PROTOCOL: Most of our USB messaging is through standard USB HID |
mjr | 48:058ace2aed1d | 263 | // classes (joystick, keyboard). We also accept control messages on our |
mjr | 48:058ace2aed1d | 264 | // primary HID interface "OUT endpoint" using a custom protocol that's |
mjr | 48:058ace2aed1d | 265 | // not defined in any USB standards (we do have to provide a USB HID |
mjr | 48:058ace2aed1d | 266 | // Report Descriptor for it, but this just describes the protocol as |
mjr | 48:058ace2aed1d | 267 | // opaque vendor-defined bytes). The control protocol incorporates the |
mjr | 48:058ace2aed1d | 268 | // LedWiz protocol as a subset, and adds our own private extensions. |
mjr | 48:058ace2aed1d | 269 | // For full details, see USBProtocol.h. |
mjr | 33:d832bcab089e | 270 | |
mjr | 33:d832bcab089e | 271 | |
mjr | 0:5acbbe3f4cf4 | 272 | #include "mbed.h" |
mjr | 6:cc35eb643e8f | 273 | #include "math.h" |
mjr | 74:822a92bc11d2 | 274 | #include "diags.h" |
mjr | 48:058ace2aed1d | 275 | #include "pinscape.h" |
mjr | 79:682ae3171a08 | 276 | #include "NewMalloc.h" |
mjr | 0:5acbbe3f4cf4 | 277 | #include "USBJoystick.h" |
mjr | 0:5acbbe3f4cf4 | 278 | #include "MMA8451Q.h" |
mjr | 1:d913e0afb2ac | 279 | #include "FreescaleIAP.h" |
mjr | 2:c174f9ee414a | 280 | #include "crc32.h" |
mjr | 26:cb71c4af2912 | 281 | #include "TLC5940.h" |
mjr | 87:8d35c74403af | 282 | #include "TLC59116.h" |
mjr | 34:6b981a2afab7 | 283 | #include "74HC595.h" |
mjr | 35:e959ffba78fd | 284 | #include "nvm.h" |
mjr | 48:058ace2aed1d | 285 | #include "TinyDigitalIn.h" |
mjr | 77:0b96f6867312 | 286 | #include "IRReceiver.h" |
mjr | 77:0b96f6867312 | 287 | #include "IRTransmitter.h" |
mjr | 77:0b96f6867312 | 288 | #include "NewPwm.h" |
mjr | 74:822a92bc11d2 | 289 | |
mjr | 82:4f6209cb5c33 | 290 | // plunger sensors |
mjr | 82:4f6209cb5c33 | 291 | #include "plunger.h" |
mjr | 82:4f6209cb5c33 | 292 | #include "edgeSensor.h" |
mjr | 82:4f6209cb5c33 | 293 | #include "potSensor.h" |
mjr | 82:4f6209cb5c33 | 294 | #include "quadSensor.h" |
mjr | 82:4f6209cb5c33 | 295 | #include "nullSensor.h" |
mjr | 82:4f6209cb5c33 | 296 | #include "barCodeSensor.h" |
mjr | 82:4f6209cb5c33 | 297 | #include "distanceSensor.h" |
mjr | 87:8d35c74403af | 298 | #include "tsl14xxSensor.h" |
mjr | 100:1ff35c07217c | 299 | #include "rotarySensor.h" |
mjr | 100:1ff35c07217c | 300 | #include "tcd1103Sensor.h" |
mjr | 82:4f6209cb5c33 | 301 | |
mjr | 2:c174f9ee414a | 302 | |
mjr | 21:5048e16cc9ef | 303 | #define DECL_EXTERNS |
mjr | 17:ab3cec0c8bf4 | 304 | #include "config.h" |
mjr | 17:ab3cec0c8bf4 | 305 | |
mjr | 53:9b2611964afc | 306 | |
mjr | 53:9b2611964afc | 307 | // -------------------------------------------------------------------------- |
mjr | 53:9b2611964afc | 308 | // |
mjr | 112:8ed709f455c0 | 309 | // placement new |
mjr | 112:8ed709f455c0 | 310 | // |
mjr | 112:8ed709f455c0 | 311 | void* operator new (size_t, void *p) { return p; } |
mjr | 112:8ed709f455c0 | 312 | |
mjr | 112:8ed709f455c0 | 313 | |
mjr | 112:8ed709f455c0 | 314 | // -------------------------------------------------------------------------- |
mjr | 112:8ed709f455c0 | 315 | // |
mjr | 53:9b2611964afc | 316 | // OpenSDA module identifier. This is for the benefit of the Windows |
mjr | 53:9b2611964afc | 317 | // configuration tool. When the config tool installs a .bin file onto |
mjr | 53:9b2611964afc | 318 | // the KL25Z, it will first find the sentinel string within the .bin file, |
mjr | 53:9b2611964afc | 319 | // and patch the "\0" bytes that follow the sentinel string with the |
mjr | 53:9b2611964afc | 320 | // OpenSDA module ID data. This allows us to report the OpenSDA |
mjr | 53:9b2611964afc | 321 | // identifiers back to the host system via USB, which in turn allows the |
mjr | 53:9b2611964afc | 322 | // config tool to figure out which OpenSDA MSD (mass storage device - a |
mjr | 53:9b2611964afc | 323 | // virtual disk drive) correlates to which Pinscape controller USB |
mjr | 53:9b2611964afc | 324 | // interface. |
mjr | 53:9b2611964afc | 325 | // |
mjr | 53:9b2611964afc | 326 | // This is only important if multiple Pinscape devices are attached to |
mjr | 53:9b2611964afc | 327 | // the same host. There doesn't seem to be any other way to figure out |
mjr | 53:9b2611964afc | 328 | // which OpenSDA MSD corresponds to which KL25Z USB interface; the OpenSDA |
mjr | 53:9b2611964afc | 329 | // MSD doesn't report the KL25Z CPU ID anywhere, and the KL25Z doesn't |
mjr | 53:9b2611964afc | 330 | // have any way to learn about the OpenSDA module it's connected to. The |
mjr | 53:9b2611964afc | 331 | // only way to pass this information to the KL25Z side that I can come up |
mjr | 53:9b2611964afc | 332 | // with is to have the Windows host embed it in the .bin file before |
mjr | 53:9b2611964afc | 333 | // downloading it to the OpenSDA MSD. |
mjr | 53:9b2611964afc | 334 | // |
mjr | 53:9b2611964afc | 335 | // We initialize the const data buffer (the part after the sentinel string) |
mjr | 53:9b2611964afc | 336 | // with all "\0" bytes, so that's what will be in the executable image that |
mjr | 53:9b2611964afc | 337 | // comes out of the mbed compiler. If you manually install the resulting |
mjr | 53:9b2611964afc | 338 | // .bin file onto the KL25Z (via the Windows desktop, say), the "\0" bytes |
mjr | 53:9b2611964afc | 339 | // will stay this way and read as all 0's at run-time. Since a real TUID |
mjr | 53:9b2611964afc | 340 | // would never be all 0's, that tells us that we were never patched and |
mjr | 53:9b2611964afc | 341 | // thus don't have any information on the OpenSDA module. |
mjr | 53:9b2611964afc | 342 | // |
mjr | 53:9b2611964afc | 343 | const char *getOpenSDAID() |
mjr | 53:9b2611964afc | 344 | { |
mjr | 53:9b2611964afc | 345 | #define OPENSDA_PREFIX "///Pinscape.OpenSDA.TUID///" |
mjr | 53:9b2611964afc | 346 | static const char OpenSDA[] = OPENSDA_PREFIX "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0///"; |
mjr | 53:9b2611964afc | 347 | const size_t OpenSDA_prefix_length = sizeof(OPENSDA_PREFIX) - 1; |
mjr | 53:9b2611964afc | 348 | |
mjr | 53:9b2611964afc | 349 | return OpenSDA + OpenSDA_prefix_length; |
mjr | 53:9b2611964afc | 350 | } |
mjr | 53:9b2611964afc | 351 | |
mjr | 53:9b2611964afc | 352 | // -------------------------------------------------------------------------- |
mjr | 53:9b2611964afc | 353 | // |
mjr | 53:9b2611964afc | 354 | // Build ID. We use the date and time of compiling the program as a build |
mjr | 53:9b2611964afc | 355 | // identifier. It would be a little nicer to use a simple serial number |
mjr | 53:9b2611964afc | 356 | // instead, but the mbed platform doesn't have a way to automate that. The |
mjr | 53:9b2611964afc | 357 | // timestamp is a pretty good proxy for a serial number in that it will |
mjr | 53:9b2611964afc | 358 | // naturally increase on each new build, which is the primary property we |
mjr | 53:9b2611964afc | 359 | // want from this. |
mjr | 53:9b2611964afc | 360 | // |
mjr | 53:9b2611964afc | 361 | // As with the embedded OpenSDA ID, we store the build timestamp with a |
mjr | 53:9b2611964afc | 362 | // sentinel string prefix, to allow automated tools to find the static data |
mjr | 53:9b2611964afc | 363 | // in the .bin file by searching for the sentinel string. In contrast to |
mjr | 53:9b2611964afc | 364 | // the OpenSDA ID, the value we store here is for tools to extract rather |
mjr | 53:9b2611964afc | 365 | // than store, since we automatically populate it via the preprocessor |
mjr | 53:9b2611964afc | 366 | // macros. |
mjr | 53:9b2611964afc | 367 | // |
mjr | 53:9b2611964afc | 368 | const char *getBuildID() |
mjr | 53:9b2611964afc | 369 | { |
mjr | 53:9b2611964afc | 370 | #define BUILDID_PREFIX "///Pinscape.Build.ID///" |
mjr | 53:9b2611964afc | 371 | static const char BuildID[] = BUILDID_PREFIX __DATE__ " " __TIME__ "///"; |
mjr | 53:9b2611964afc | 372 | const size_t BuildID_prefix_length = sizeof(BUILDID_PREFIX) - 1; |
mjr | 53:9b2611964afc | 373 | |
mjr | 53:9b2611964afc | 374 | return BuildID + BuildID_prefix_length; |
mjr | 53:9b2611964afc | 375 | } |
mjr | 53:9b2611964afc | 376 | |
mjr | 74:822a92bc11d2 | 377 | // -------------------------------------------------------------------------- |
mjr | 74:822a92bc11d2 | 378 | // Main loop iteration timing statistics. Collected only if |
mjr | 74:822a92bc11d2 | 379 | // ENABLE_DIAGNOSTICS is set in diags.h. |
mjr | 76:7f5912b6340e | 380 | #if ENABLE_DIAGNOSTICS |
mjr | 76:7f5912b6340e | 381 | uint64_t mainLoopIterTime, mainLoopIterCheckpt[15], mainLoopIterCount; |
mjr | 76:7f5912b6340e | 382 | uint64_t mainLoopMsgTime, mainLoopMsgCount; |
mjr | 76:7f5912b6340e | 383 | Timer mainLoopTimer; |
mjr | 76:7f5912b6340e | 384 | #endif |
mjr | 76:7f5912b6340e | 385 | |
mjr | 53:9b2611964afc | 386 | |
mjr | 5:a70c0bce770d | 387 | // --------------------------------------------------------------------------- |
mjr | 38:091e511ce8a0 | 388 | // |
mjr | 38:091e511ce8a0 | 389 | // Forward declarations |
mjr | 38:091e511ce8a0 | 390 | // |
mjr | 38:091e511ce8a0 | 391 | void setNightMode(bool on); |
mjr | 38:091e511ce8a0 | 392 | void toggleNightMode(); |
mjr | 38:091e511ce8a0 | 393 | |
mjr | 38:091e511ce8a0 | 394 | // --------------------------------------------------------------------------- |
mjr | 17:ab3cec0c8bf4 | 395 | // utilities |
mjr | 17:ab3cec0c8bf4 | 396 | |
mjr | 77:0b96f6867312 | 397 | // int/float point square of a number |
mjr | 77:0b96f6867312 | 398 | inline int square(int x) { return x*x; } |
mjr | 26:cb71c4af2912 | 399 | inline float square(float x) { return x*x; } |
mjr | 26:cb71c4af2912 | 400 | |
mjr | 26:cb71c4af2912 | 401 | // floating point rounding |
mjr | 26:cb71c4af2912 | 402 | inline float round(float x) { return x > 0 ? floor(x + 0.5) : ceil(x - 0.5); } |
mjr | 26:cb71c4af2912 | 403 | |
mjr | 17:ab3cec0c8bf4 | 404 | |
mjr | 33:d832bcab089e | 405 | // -------------------------------------------------------------------------- |
mjr | 33:d832bcab089e | 406 | // |
mjr | 40:cc0d9814522b | 407 | // Extended verison of Timer class. This adds the ability to interrogate |
mjr | 40:cc0d9814522b | 408 | // the running state. |
mjr | 40:cc0d9814522b | 409 | // |
mjr | 77:0b96f6867312 | 410 | class ExtTimer: public Timer |
mjr | 40:cc0d9814522b | 411 | { |
mjr | 40:cc0d9814522b | 412 | public: |
mjr | 77:0b96f6867312 | 413 | ExtTimer() : running(false) { } |
mjr | 40:cc0d9814522b | 414 | |
mjr | 40:cc0d9814522b | 415 | void start() { running = true; Timer::start(); } |
mjr | 40:cc0d9814522b | 416 | void stop() { running = false; Timer::stop(); } |
mjr | 40:cc0d9814522b | 417 | |
mjr | 40:cc0d9814522b | 418 | bool isRunning() const { return running; } |
mjr | 40:cc0d9814522b | 419 | |
mjr | 40:cc0d9814522b | 420 | private: |
mjr | 40:cc0d9814522b | 421 | bool running; |
mjr | 40:cc0d9814522b | 422 | }; |
mjr | 40:cc0d9814522b | 423 | |
mjr | 53:9b2611964afc | 424 | |
mjr | 53:9b2611964afc | 425 | // -------------------------------------------------------------------------- |
mjr | 40:cc0d9814522b | 426 | // |
mjr | 33:d832bcab089e | 427 | // USB product version number |
mjr | 5:a70c0bce770d | 428 | // |
mjr | 47:df7a88cd249c | 429 | const uint16_t USB_VERSION_NO = 0x000A; |
mjr | 33:d832bcab089e | 430 | |
mjr | 33:d832bcab089e | 431 | // -------------------------------------------------------------------------- |
mjr | 33:d832bcab089e | 432 | // |
mjr | 6:cc35eb643e8f | 433 | // Joystick axis report range - we report from -JOYMAX to +JOYMAX |
mjr | 33:d832bcab089e | 434 | // |
mjr | 6:cc35eb643e8f | 435 | #define JOYMAX 4096 |
mjr | 6:cc35eb643e8f | 436 | |
mjr | 9:fd65b0a94720 | 437 | |
mjr | 17:ab3cec0c8bf4 | 438 | // --------------------------------------------------------------------------- |
mjr | 17:ab3cec0c8bf4 | 439 | // |
mjr | 40:cc0d9814522b | 440 | // Wire protocol value translations. These translate byte values to and |
mjr | 40:cc0d9814522b | 441 | // from the USB protocol to local native format. |
mjr | 35:e959ffba78fd | 442 | // |
mjr | 35:e959ffba78fd | 443 | |
mjr | 35:e959ffba78fd | 444 | // unsigned 16-bit integer |
mjr | 35:e959ffba78fd | 445 | inline uint16_t wireUI16(const uint8_t *b) |
mjr | 35:e959ffba78fd | 446 | { |
mjr | 35:e959ffba78fd | 447 | return b[0] | ((uint16_t)b[1] << 8); |
mjr | 35:e959ffba78fd | 448 | } |
mjr | 40:cc0d9814522b | 449 | inline void ui16Wire(uint8_t *b, uint16_t val) |
mjr | 40:cc0d9814522b | 450 | { |
mjr | 40:cc0d9814522b | 451 | b[0] = (uint8_t)(val & 0xff); |
mjr | 40:cc0d9814522b | 452 | b[1] = (uint8_t)((val >> 8) & 0xff); |
mjr | 40:cc0d9814522b | 453 | } |
mjr | 35:e959ffba78fd | 454 | |
mjr | 35:e959ffba78fd | 455 | inline int16_t wireI16(const uint8_t *b) |
mjr | 35:e959ffba78fd | 456 | { |
mjr | 35:e959ffba78fd | 457 | return (int16_t)wireUI16(b); |
mjr | 35:e959ffba78fd | 458 | } |
mjr | 40:cc0d9814522b | 459 | inline void i16Wire(uint8_t *b, int16_t val) |
mjr | 40:cc0d9814522b | 460 | { |
mjr | 40:cc0d9814522b | 461 | ui16Wire(b, (uint16_t)val); |
mjr | 40:cc0d9814522b | 462 | } |
mjr | 35:e959ffba78fd | 463 | |
mjr | 35:e959ffba78fd | 464 | inline uint32_t wireUI32(const uint8_t *b) |
mjr | 35:e959ffba78fd | 465 | { |
mjr | 35:e959ffba78fd | 466 | return b[0] | ((uint32_t)b[1] << 8) | ((uint32_t)b[2] << 16) | ((uint32_t)b[3] << 24); |
mjr | 35:e959ffba78fd | 467 | } |
mjr | 40:cc0d9814522b | 468 | inline void ui32Wire(uint8_t *b, uint32_t val) |
mjr | 40:cc0d9814522b | 469 | { |
mjr | 40:cc0d9814522b | 470 | b[0] = (uint8_t)(val & 0xff); |
mjr | 40:cc0d9814522b | 471 | b[1] = (uint8_t)((val >> 8) & 0xff); |
mjr | 40:cc0d9814522b | 472 | b[2] = (uint8_t)((val >> 16) & 0xff); |
mjr | 40:cc0d9814522b | 473 | b[3] = (uint8_t)((val >> 24) & 0xff); |
mjr | 40:cc0d9814522b | 474 | } |
mjr | 35:e959ffba78fd | 475 | |
mjr | 35:e959ffba78fd | 476 | inline int32_t wireI32(const uint8_t *b) |
mjr | 35:e959ffba78fd | 477 | { |
mjr | 35:e959ffba78fd | 478 | return (int32_t)wireUI32(b); |
mjr | 35:e959ffba78fd | 479 | } |
mjr | 35:e959ffba78fd | 480 | |
mjr | 53:9b2611964afc | 481 | // Convert "wire" (USB) pin codes to/from PinName values. |
mjr | 53:9b2611964afc | 482 | // |
mjr | 53:9b2611964afc | 483 | // The internal mbed PinName format is |
mjr | 53:9b2611964afc | 484 | // |
mjr | 53:9b2611964afc | 485 | // ((port) << PORT_SHIFT) | (pin << 2) // MBED FORMAT |
mjr | 53:9b2611964afc | 486 | // |
mjr | 53:9b2611964afc | 487 | // where 'port' is 0-4 for Port A to Port E, and 'pin' is |
mjr | 53:9b2611964afc | 488 | // 0 to 31. E.g., E31 is (4 << PORT_SHIFT) | (31<<2). |
mjr | 53:9b2611964afc | 489 | // |
mjr | 53:9b2611964afc | 490 | // We remap this to our more compact wire format where each |
mjr | 53:9b2611964afc | 491 | // pin name fits in 8 bits: |
mjr | 53:9b2611964afc | 492 | // |
mjr | 53:9b2611964afc | 493 | // ((port) << 5) | pin) // WIRE FORMAT |
mjr | 53:9b2611964afc | 494 | // |
mjr | 53:9b2611964afc | 495 | // E.g., E31 is (4 << 5) | 31. |
mjr | 53:9b2611964afc | 496 | // |
mjr | 53:9b2611964afc | 497 | // Wire code FF corresponds to PinName NC (not connected). |
mjr | 53:9b2611964afc | 498 | // |
mjr | 53:9b2611964afc | 499 | inline PinName wirePinName(uint8_t c) |
mjr | 35:e959ffba78fd | 500 | { |
mjr | 53:9b2611964afc | 501 | if (c == 0xFF) |
mjr | 53:9b2611964afc | 502 | return NC; // 0xFF -> NC |
mjr | 53:9b2611964afc | 503 | else |
mjr | 53:9b2611964afc | 504 | return PinName( |
mjr | 53:9b2611964afc | 505 | (int(c & 0xE0) << (PORT_SHIFT - 5)) // top three bits are the port |
mjr | 53:9b2611964afc | 506 | | (int(c & 0x1F) << 2)); // bottom five bits are pin |
mjr | 40:cc0d9814522b | 507 | } |
mjr | 40:cc0d9814522b | 508 | inline void pinNameWire(uint8_t *b, PinName n) |
mjr | 40:cc0d9814522b | 509 | { |
mjr | 53:9b2611964afc | 510 | *b = PINNAME_TO_WIRE(n); |
mjr | 35:e959ffba78fd | 511 | } |
mjr | 35:e959ffba78fd | 512 | |
mjr | 35:e959ffba78fd | 513 | |
mjr | 35:e959ffba78fd | 514 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 515 | // |
mjr | 38:091e511ce8a0 | 516 | // On-board RGB LED elements - we use these for diagnostic displays. |
mjr | 38:091e511ce8a0 | 517 | // |
mjr | 38:091e511ce8a0 | 518 | // Note that LED3 (the blue segment) is hard-wired on the KL25Z to PTD1, |
mjr | 38:091e511ce8a0 | 519 | // so PTD1 shouldn't be used for any other purpose (e.g., as a keyboard |
mjr | 38:091e511ce8a0 | 520 | // input or a device output). This is kind of unfortunate in that it's |
mjr | 38:091e511ce8a0 | 521 | // one of only two ports exposed on the jumper pins that can be muxed to |
mjr | 38:091e511ce8a0 | 522 | // SPI0 SCLK. This effectively limits us to PTC5 if we want to use the |
mjr | 38:091e511ce8a0 | 523 | // SPI capability. |
mjr | 38:091e511ce8a0 | 524 | // |
mjr | 38:091e511ce8a0 | 525 | DigitalOut *ledR, *ledG, *ledB; |
mjr | 38:091e511ce8a0 | 526 | |
mjr | 73:4e8ce0b18915 | 527 | // Power on timer state for diagnostics. We flash the blue LED when |
mjr | 77:0b96f6867312 | 528 | // nothing else is going on. State 0-1 = off, 2-3 = on blue. Also |
mjr | 77:0b96f6867312 | 529 | // show red when transmitting an LED signal, indicated by state 4. |
mjr | 73:4e8ce0b18915 | 530 | uint8_t powerTimerDiagState = 0; |
mjr | 73:4e8ce0b18915 | 531 | |
mjr | 38:091e511ce8a0 | 532 | // Show the indicated pattern on the diagnostic LEDs. 0 is off, 1 is |
mjr | 38:091e511ce8a0 | 533 | // on, and -1 is no change (leaves the current setting intact). |
mjr | 73:4e8ce0b18915 | 534 | static uint8_t diagLEDState = 0; |
mjr | 38:091e511ce8a0 | 535 | void diagLED(int r, int g, int b) |
mjr | 38:091e511ce8a0 | 536 | { |
mjr | 73:4e8ce0b18915 | 537 | // remember the new state |
mjr | 73:4e8ce0b18915 | 538 | diagLEDState = r | (g << 1) | (b << 2); |
mjr | 73:4e8ce0b18915 | 539 | |
mjr | 73:4e8ce0b18915 | 540 | // if turning everything off, use the power timer state instead, |
mjr | 73:4e8ce0b18915 | 541 | // applying it to the blue LED |
mjr | 73:4e8ce0b18915 | 542 | if (diagLEDState == 0) |
mjr | 77:0b96f6867312 | 543 | { |
mjr | 77:0b96f6867312 | 544 | b = (powerTimerDiagState == 2 || powerTimerDiagState == 3); |
mjr | 77:0b96f6867312 | 545 | r = (powerTimerDiagState == 4); |
mjr | 77:0b96f6867312 | 546 | } |
mjr | 73:4e8ce0b18915 | 547 | |
mjr | 73:4e8ce0b18915 | 548 | // set the new state |
mjr | 38:091e511ce8a0 | 549 | if (ledR != 0 && r != -1) ledR->write(!r); |
mjr | 38:091e511ce8a0 | 550 | if (ledG != 0 && g != -1) ledG->write(!g); |
mjr | 38:091e511ce8a0 | 551 | if (ledB != 0 && b != -1) ledB->write(!b); |
mjr | 38:091e511ce8a0 | 552 | } |
mjr | 38:091e511ce8a0 | 553 | |
mjr | 73:4e8ce0b18915 | 554 | // update the LEDs with the current state |
mjr | 73:4e8ce0b18915 | 555 | void diagLED(void) |
mjr | 73:4e8ce0b18915 | 556 | { |
mjr | 73:4e8ce0b18915 | 557 | diagLED( |
mjr | 73:4e8ce0b18915 | 558 | diagLEDState & 0x01, |
mjr | 73:4e8ce0b18915 | 559 | (diagLEDState >> 1) & 0x01, |
mjr | 77:0b96f6867312 | 560 | (diagLEDState >> 2) & 0x01); |
mjr | 73:4e8ce0b18915 | 561 | } |
mjr | 73:4e8ce0b18915 | 562 | |
mjr | 106:e9e3b46132c1 | 563 | // check an output port or pin assignment to see if it conflicts with |
mjr | 38:091e511ce8a0 | 564 | // an on-board LED segment |
mjr | 38:091e511ce8a0 | 565 | struct LedSeg |
mjr | 38:091e511ce8a0 | 566 | { |
mjr | 38:091e511ce8a0 | 567 | bool r, g, b; |
mjr | 38:091e511ce8a0 | 568 | LedSeg() { r = g = b = false; } |
mjr | 38:091e511ce8a0 | 569 | |
mjr | 106:e9e3b46132c1 | 570 | // check an output port to see if it conflicts with one of the LED ports |
mjr | 38:091e511ce8a0 | 571 | void check(LedWizPortCfg &pc) |
mjr | 38:091e511ce8a0 | 572 | { |
mjr | 38:091e511ce8a0 | 573 | // if it's a GPIO, check to see if it's assigned to one of |
mjr | 38:091e511ce8a0 | 574 | // our on-board LED segments |
mjr | 38:091e511ce8a0 | 575 | int t = pc.typ; |
mjr | 38:091e511ce8a0 | 576 | if (t == PortTypeGPIOPWM || t == PortTypeGPIODig) |
mjr | 106:e9e3b46132c1 | 577 | check(pc.pin); |
mjr | 106:e9e3b46132c1 | 578 | } |
mjr | 106:e9e3b46132c1 | 579 | |
mjr | 106:e9e3b46132c1 | 580 | // check a pin to see if it conflicts with one of the diagnostic LED ports |
mjr | 106:e9e3b46132c1 | 581 | void check(uint8_t pinId) |
mjr | 106:e9e3b46132c1 | 582 | { |
mjr | 106:e9e3b46132c1 | 583 | PinName pin = wirePinName(pinId); |
mjr | 106:e9e3b46132c1 | 584 | if (pin == LED1) |
mjr | 106:e9e3b46132c1 | 585 | r = true; |
mjr | 106:e9e3b46132c1 | 586 | else if (pin == LED2) |
mjr | 106:e9e3b46132c1 | 587 | g = true; |
mjr | 106:e9e3b46132c1 | 588 | else if (pin == LED3) |
mjr | 106:e9e3b46132c1 | 589 | b = true; |
mjr | 38:091e511ce8a0 | 590 | } |
mjr | 38:091e511ce8a0 | 591 | }; |
mjr | 38:091e511ce8a0 | 592 | |
mjr | 38:091e511ce8a0 | 593 | // Initialize the diagnostic LEDs. By default, we use the on-board |
mjr | 38:091e511ce8a0 | 594 | // RGB LED to display the microcontroller status. However, we allow |
mjr | 38:091e511ce8a0 | 595 | // the user to commandeer the on-board LED as an LedWiz output device, |
mjr | 38:091e511ce8a0 | 596 | // which can be useful for testing a new installation. So we'll check |
mjr | 38:091e511ce8a0 | 597 | // for LedWiz outputs assigned to the on-board LED segments, and turn |
mjr | 38:091e511ce8a0 | 598 | // off the diagnostic use for any so assigned. |
mjr | 38:091e511ce8a0 | 599 | void initDiagLEDs(Config &cfg) |
mjr | 38:091e511ce8a0 | 600 | { |
mjr | 38:091e511ce8a0 | 601 | // run through the configuration list and cross off any of the |
mjr | 38:091e511ce8a0 | 602 | // LED segments assigned to LedWiz ports |
mjr | 38:091e511ce8a0 | 603 | LedSeg l; |
mjr | 38:091e511ce8a0 | 604 | for (int i = 0 ; i < MAX_OUT_PORTS && cfg.outPort[i].typ != PortTypeDisabled ; ++i) |
mjr | 38:091e511ce8a0 | 605 | l.check(cfg.outPort[i]); |
mjr | 106:e9e3b46132c1 | 606 | |
mjr | 106:e9e3b46132c1 | 607 | // check the button inputs |
mjr | 106:e9e3b46132c1 | 608 | for (int i = 0 ; i < countof(cfg.button) ; ++i) |
mjr | 106:e9e3b46132c1 | 609 | l.check(cfg.button[i].pin); |
mjr | 106:e9e3b46132c1 | 610 | |
mjr | 106:e9e3b46132c1 | 611 | // check plunger inputs |
mjr | 106:e9e3b46132c1 | 612 | if (cfg.plunger.enabled && cfg.plunger.sensorType != PlungerType_None) |
mjr | 106:e9e3b46132c1 | 613 | { |
mjr | 106:e9e3b46132c1 | 614 | for (int i = 0 ; i < countof(cfg.plunger.sensorPin) ; ++i) |
mjr | 106:e9e3b46132c1 | 615 | l.check(cfg.plunger.sensorPin[i]); |
mjr | 107:8f3c7aeae7e0 | 616 | |
mjr | 107:8f3c7aeae7e0 | 617 | l.check(cfg.plunger.cal.btn); |
mjr | 107:8f3c7aeae7e0 | 618 | l.check(cfg.plunger.cal.led); |
mjr | 106:e9e3b46132c1 | 619 | } |
mjr | 106:e9e3b46132c1 | 620 | |
mjr | 106:e9e3b46132c1 | 621 | // check the TV ON pin assignments |
mjr | 106:e9e3b46132c1 | 622 | l.check(cfg.TVON.statusPin); |
mjr | 106:e9e3b46132c1 | 623 | l.check(cfg.TVON.latchPin); |
mjr | 106:e9e3b46132c1 | 624 | l.check(cfg.TVON.relayPin); |
mjr | 106:e9e3b46132c1 | 625 | |
mjr | 106:e9e3b46132c1 | 626 | // check the TLC5940 pins |
mjr | 106:e9e3b46132c1 | 627 | if (cfg.tlc5940.nchips != 0) |
mjr | 106:e9e3b46132c1 | 628 | { |
mjr | 106:e9e3b46132c1 | 629 | l.check(cfg.tlc5940.sin); |
mjr | 106:e9e3b46132c1 | 630 | l.check(cfg.tlc5940.sclk); |
mjr | 106:e9e3b46132c1 | 631 | l.check(cfg.tlc5940.xlat); |
mjr | 106:e9e3b46132c1 | 632 | l.check(cfg.tlc5940.blank); |
mjr | 106:e9e3b46132c1 | 633 | l.check(cfg.tlc5940.gsclk); |
mjr | 106:e9e3b46132c1 | 634 | } |
mjr | 106:e9e3b46132c1 | 635 | |
mjr | 106:e9e3b46132c1 | 636 | // check 74HC595 pin assignments |
mjr | 106:e9e3b46132c1 | 637 | if (cfg.hc595.nchips != 0) |
mjr | 106:e9e3b46132c1 | 638 | { |
mjr | 106:e9e3b46132c1 | 639 | l.check(cfg.hc595.sin); |
mjr | 106:e9e3b46132c1 | 640 | l.check(cfg.hc595.sclk); |
mjr | 106:e9e3b46132c1 | 641 | l.check(cfg.hc595.latch); |
mjr | 106:e9e3b46132c1 | 642 | l.check(cfg.hc595.ena); |
mjr | 106:e9e3b46132c1 | 643 | } |
mjr | 106:e9e3b46132c1 | 644 | |
mjr | 106:e9e3b46132c1 | 645 | // check TLC59116 pin assignments |
mjr | 106:e9e3b46132c1 | 646 | if (cfg.tlc59116.chipMask != 0) |
mjr | 106:e9e3b46132c1 | 647 | { |
mjr | 106:e9e3b46132c1 | 648 | l.check(cfg.tlc59116.sda); |
mjr | 106:e9e3b46132c1 | 649 | l.check(cfg.tlc59116.scl); |
mjr | 106:e9e3b46132c1 | 650 | l.check(cfg.tlc59116.reset); |
mjr | 106:e9e3b46132c1 | 651 | } |
mjr | 106:e9e3b46132c1 | 652 | |
mjr | 106:e9e3b46132c1 | 653 | // check the IR remove control hardware |
mjr | 106:e9e3b46132c1 | 654 | l.check(cfg.IR.sensor); |
mjr | 106:e9e3b46132c1 | 655 | l.check(cfg.IR.emitter); |
mjr | 106:e9e3b46132c1 | 656 | |
mjr | 106:e9e3b46132c1 | 657 | // We now know which segments are taken for other uses and which |
mjr | 38:091e511ce8a0 | 658 | // are free. Create diagnostic ports for the ones not claimed for |
mjr | 106:e9e3b46132c1 | 659 | // other purposes. |
mjr | 38:091e511ce8a0 | 660 | if (!l.r) ledR = new DigitalOut(LED1, 1); |
mjr | 38:091e511ce8a0 | 661 | if (!l.g) ledG = new DigitalOut(LED2, 1); |
mjr | 38:091e511ce8a0 | 662 | if (!l.b) ledB = new DigitalOut(LED3, 1); |
mjr | 38:091e511ce8a0 | 663 | } |
mjr | 38:091e511ce8a0 | 664 | |
mjr | 38:091e511ce8a0 | 665 | |
mjr | 38:091e511ce8a0 | 666 | // --------------------------------------------------------------------------- |
mjr | 38:091e511ce8a0 | 667 | // |
mjr | 76:7f5912b6340e | 668 | // LedWiz emulation |
mjr | 76:7f5912b6340e | 669 | // |
mjr | 76:7f5912b6340e | 670 | |
mjr | 76:7f5912b6340e | 671 | // LedWiz output states. |
mjr | 76:7f5912b6340e | 672 | // |
mjr | 76:7f5912b6340e | 673 | // The LedWiz protocol has two separate control axes for each output. |
mjr | 76:7f5912b6340e | 674 | // One axis is its on/off state; the other is its "profile" state, which |
mjr | 76:7f5912b6340e | 675 | // is either a fixed brightness or a blinking pattern for the light. |
mjr | 76:7f5912b6340e | 676 | // The two axes are independent. |
mjr | 76:7f5912b6340e | 677 | // |
mjr | 76:7f5912b6340e | 678 | // Even though the original LedWiz protocol can only access 32 ports, we |
mjr | 76:7f5912b6340e | 679 | // maintain LedWiz state for every port, even if we have more than 32. Our |
mjr | 76:7f5912b6340e | 680 | // extended protocol allows the client to send LedWiz-style messages that |
mjr | 76:7f5912b6340e | 681 | // control any set of ports. A replacement LEDWIZ.DLL can make a single |
mjr | 76:7f5912b6340e | 682 | // Pinscape unit look like multiple virtual LedWiz units to legacy clients, |
mjr | 76:7f5912b6340e | 683 | // allowing them to control all of our ports. The clients will still be |
mjr | 76:7f5912b6340e | 684 | // using LedWiz-style states to control the ports, so we need to support |
mjr | 76:7f5912b6340e | 685 | // the LedWiz scheme with separate on/off and brightness control per port. |
mjr | 76:7f5912b6340e | 686 | |
mjr | 76:7f5912b6340e | 687 | // On/off state for each LedWiz output |
mjr | 76:7f5912b6340e | 688 | static uint8_t *wizOn; |
mjr | 76:7f5912b6340e | 689 | |
mjr | 76:7f5912b6340e | 690 | // LedWiz "Profile State" (the LedWiz brightness level or blink mode) |
mjr | 76:7f5912b6340e | 691 | // for each LedWiz output. If the output was last updated through an |
mjr | 76:7f5912b6340e | 692 | // LedWiz protocol message, it will have one of these values: |
mjr | 76:7f5912b6340e | 693 | // |
mjr | 76:7f5912b6340e | 694 | // 0-48 = fixed brightness 0% to 100% |
mjr | 76:7f5912b6340e | 695 | // 49 = fixed brightness 100% (equivalent to 48) |
mjr | 76:7f5912b6340e | 696 | // 129 = ramp up / ramp down |
mjr | 76:7f5912b6340e | 697 | // 130 = flash on / off |
mjr | 76:7f5912b6340e | 698 | // 131 = on / ramp down |
mjr | 76:7f5912b6340e | 699 | // 132 = ramp up / on |
mjr | 5:a70c0bce770d | 700 | // |
mjr | 76:7f5912b6340e | 701 | // (Note that value 49 isn't documented in the LedWiz spec, but real |
mjr | 76:7f5912b6340e | 702 | // LedWiz units treat it as equivalent to 48, and some PC software uses |
mjr | 76:7f5912b6340e | 703 | // it, so we need to accept it for compatibility.) |
mjr | 76:7f5912b6340e | 704 | static uint8_t *wizVal; |
mjr | 76:7f5912b6340e | 705 | |
mjr | 76:7f5912b6340e | 706 | // Current actual brightness for each output. This is a simple linear |
mjr | 76:7f5912b6340e | 707 | // value on a 0..255 scale. This is EITHER the linear brightness computed |
mjr | 76:7f5912b6340e | 708 | // from the LedWiz setting for the port, OR the 0..255 value set explicitly |
mjr | 76:7f5912b6340e | 709 | // by the extended protocol: |
mjr | 76:7f5912b6340e | 710 | // |
mjr | 76:7f5912b6340e | 711 | // - If the last command that updated the port was an extended protocol |
mjr | 76:7f5912b6340e | 712 | // SET BRIGHTNESS command, this is the value set by that command. In |
mjr | 76:7f5912b6340e | 713 | // addition, wizOn[port] is set to 0 if the brightness is 0, 1 otherwise; |
mjr | 76:7f5912b6340e | 714 | // and wizVal[port] is set to the brightness rescaled to the 0..48 range |
mjr | 76:7f5912b6340e | 715 | // if the brightness is non-zero. |
mjr | 76:7f5912b6340e | 716 | // |
mjr | 76:7f5912b6340e | 717 | // - If the last command that updated the port was an LedWiz command |
mjr | 76:7f5912b6340e | 718 | // (SBA/PBA/SBX/PBX), this contains the brightness value computed from |
mjr | 76:7f5912b6340e | 719 | // the combination of wizOn[port] and wizVal[port]. If wizOn[port] is |
mjr | 76:7f5912b6340e | 720 | // zero, this is simply 0, otherwise it's wizVal[port] rescaled to the |
mjr | 76:7f5912b6340e | 721 | // 0..255 range. |
mjr | 26:cb71c4af2912 | 722 | // |
mjr | 76:7f5912b6340e | 723 | // - For a port set to wizOn[port]=1 and wizVal[port] in 129..132, this is |
mjr | 76:7f5912b6340e | 724 | // also updated continuously to reflect the current flashing brightness |
mjr | 76:7f5912b6340e | 725 | // level. |
mjr | 26:cb71c4af2912 | 726 | // |
mjr | 76:7f5912b6340e | 727 | static uint8_t *outLevel; |
mjr | 76:7f5912b6340e | 728 | |
mjr | 76:7f5912b6340e | 729 | |
mjr | 76:7f5912b6340e | 730 | // LedWiz flash speed. This is a value from 1 to 7 giving the pulse |
mjr | 76:7f5912b6340e | 731 | // rate for lights in blinking states. The LedWiz API doesn't document |
mjr | 76:7f5912b6340e | 732 | // what the numbers mean in real time units, but by observation, the |
mjr | 76:7f5912b6340e | 733 | // "speed" setting represents the period of the flash cycle in 0.25s |
mjr | 76:7f5912b6340e | 734 | // units, so speed 1 = 0.25 period = 4Hz, speed 7 = 1.75s period = 0.57Hz. |
mjr | 76:7f5912b6340e | 735 | // The period is the full cycle time of the flash waveform. |
mjr | 76:7f5912b6340e | 736 | // |
mjr | 76:7f5912b6340e | 737 | // Each bank of 32 lights has its independent own pulse rate, so we need |
mjr | 76:7f5912b6340e | 738 | // one entry per bank. Each bank has 32 outputs, so we need a total of |
mjr | 76:7f5912b6340e | 739 | // ceil(number_of_physical_outputs/32) entries. Note that we could allocate |
mjr | 76:7f5912b6340e | 740 | // this dynamically once we know the number of actual outputs, but the |
mjr | 76:7f5912b6340e | 741 | // upper limit is low enough that it's more efficient to use a fixed array |
mjr | 76:7f5912b6340e | 742 | // at the maximum size. |
mjr | 76:7f5912b6340e | 743 | static const int MAX_LW_BANKS = (MAX_OUT_PORTS+31)/32; |
mjr | 76:7f5912b6340e | 744 | static uint8_t wizSpeed[MAX_LW_BANKS]; |
mjr | 29:582472d0bc57 | 745 | |
mjr | 26:cb71c4af2912 | 746 | // Current starting output index for "PBA" messages from the PC (using |
mjr | 26:cb71c4af2912 | 747 | // the LedWiz USB protocol). Each PBA message implicitly uses the |
mjr | 26:cb71c4af2912 | 748 | // current index as the starting point for the ports referenced in |
mjr | 26:cb71c4af2912 | 749 | // the message, and increases it (by 8) for the next call. |
mjr | 0:5acbbe3f4cf4 | 750 | static int pbaIdx = 0; |
mjr | 0:5acbbe3f4cf4 | 751 | |
mjr | 76:7f5912b6340e | 752 | |
mjr | 76:7f5912b6340e | 753 | // --------------------------------------------------------------------------- |
mjr | 76:7f5912b6340e | 754 | // |
mjr | 76:7f5912b6340e | 755 | // Output Ports |
mjr | 76:7f5912b6340e | 756 | // |
mjr | 76:7f5912b6340e | 757 | // There are two way to connect outputs. First, you can use the on-board |
mjr | 76:7f5912b6340e | 758 | // GPIO ports to implement device outputs: each LedWiz software port is |
mjr | 76:7f5912b6340e | 759 | // connected to a physical GPIO pin on the KL25Z. This has some pretty |
mjr | 76:7f5912b6340e | 760 | // strict limits, though. The KL25Z only has 10 PWM channels, so only 10 |
mjr | 76:7f5912b6340e | 761 | // GPIO LedWiz ports can be made dimmable; the rest are strictly on/off. |
mjr | 76:7f5912b6340e | 762 | // The KL25Z also simply doesn't have enough exposed GPIO ports overall to |
mjr | 76:7f5912b6340e | 763 | // support all of the features the software supports. The software allows |
mjr | 76:7f5912b6340e | 764 | // for up to 128 outputs, 48 button inputs, plunger input (requiring 1-5 |
mjr | 76:7f5912b6340e | 765 | // GPIO pins), and various other external devices. The KL25Z only exposes |
mjr | 76:7f5912b6340e | 766 | // about 50 GPIO pins. So if you want to do everything with GPIO ports, |
mjr | 76:7f5912b6340e | 767 | // you have to ration pins among features. |
mjr | 76:7f5912b6340e | 768 | // |
mjr | 87:8d35c74403af | 769 | // To overcome some of these limitations, we also support several external |
mjr | 76:7f5912b6340e | 770 | // peripheral controllers that allow adding many more outputs, using only |
mjr | 87:8d35c74403af | 771 | // a small number of GPIO pins to interface with the peripherals: |
mjr | 87:8d35c74403af | 772 | // |
mjr | 87:8d35c74403af | 773 | // - TLC5940 PWM controller chips. Each TLC5940 provides 16 ports with |
mjr | 87:8d35c74403af | 774 | // 12-bit PWM, and multiple TLC5940 chips can be daisy-chained. The |
mjr | 87:8d35c74403af | 775 | // chips connect via 5 GPIO pins, and since they're daisy-chainable, |
mjr | 87:8d35c74403af | 776 | // one set of 5 pins can control any number of the chips. So this chip |
mjr | 87:8d35c74403af | 777 | // effectively converts 5 GPIO pins into almost any number of PWM outputs. |
mjr | 87:8d35c74403af | 778 | // |
mjr | 87:8d35c74403af | 779 | // - TLC59116 PWM controller chips. These are similar to the TLC5940 but |
mjr | 87:8d35c74403af | 780 | // a newer generation with an improved design. These use an I2C bus, |
mjr | 87:8d35c74403af | 781 | // allowing up to 14 chips to be connected via 3 GPIO pins. |
mjr | 87:8d35c74403af | 782 | // |
mjr | 87:8d35c74403af | 783 | // - 74HC595 shift register chips. These provide 8 digital (on/off only) |
mjr | 87:8d35c74403af | 784 | // outputs per chip. These need 4 GPIO pins, and like the other can be |
mjr | 87:8d35c74403af | 785 | // daisy chained to add more outputs without using more GPIO pins. These |
mjr | 87:8d35c74403af | 786 | // are advantageous for outputs that don't require PWM, since the data |
mjr | 87:8d35c74403af | 787 | // transfer sizes are so much smaller. The expansion boards use these |
mjr | 87:8d35c74403af | 788 | // for the chime board outputs. |
mjr | 76:7f5912b6340e | 789 | // |
mjr | 76:7f5912b6340e | 790 | // Direct GPIO output ports and peripheral controllers can be mixed and |
mjr | 76:7f5912b6340e | 791 | // matched in one system. The assignment of pins to ports and the |
mjr | 76:7f5912b6340e | 792 | // configuration of peripheral controllers is all handled in the software |
mjr | 76:7f5912b6340e | 793 | // setup, so a physical system can be expanded and updated at any time. |
mjr | 76:7f5912b6340e | 794 | // |
mjr | 76:7f5912b6340e | 795 | // To handle the diversity of output port types, we start with an abstract |
mjr | 76:7f5912b6340e | 796 | // base class for outputs. Each type of physical output interface has a |
mjr | 76:7f5912b6340e | 797 | // concrete subclass. During initialization, we create the appropriate |
mjr | 76:7f5912b6340e | 798 | // subclass for each software port, mapping it to the assigned GPIO pin |
mjr | 76:7f5912b6340e | 799 | // or peripheral port. Most of the rest of the software only cares about |
mjr | 76:7f5912b6340e | 800 | // the abstract interface, so once the subclassed port objects are set up, |
mjr | 76:7f5912b6340e | 801 | // the rest of the system can control the ports without knowing which types |
mjr | 76:7f5912b6340e | 802 | // of physical devices they're connected to. |
mjr | 76:7f5912b6340e | 803 | |
mjr | 76:7f5912b6340e | 804 | |
mjr | 26:cb71c4af2912 | 805 | // Generic LedWiz output port interface. We create a cover class to |
mjr | 26:cb71c4af2912 | 806 | // virtualize digital vs PWM outputs, and on-board KL25Z GPIO vs external |
mjr | 26:cb71c4af2912 | 807 | // TLC5940 outputs, and give them all a common interface. |
mjr | 6:cc35eb643e8f | 808 | class LwOut |
mjr | 6:cc35eb643e8f | 809 | { |
mjr | 6:cc35eb643e8f | 810 | public: |
mjr | 40:cc0d9814522b | 811 | // Set the output intensity. 'val' is 0 for fully off, 255 for |
mjr | 40:cc0d9814522b | 812 | // fully on, with values in between signifying lower intensity. |
mjr | 40:cc0d9814522b | 813 | virtual void set(uint8_t val) = 0; |
mjr | 6:cc35eb643e8f | 814 | }; |
mjr | 26:cb71c4af2912 | 815 | |
mjr | 35:e959ffba78fd | 816 | // LwOut class for virtual ports. This type of port is visible to |
mjr | 35:e959ffba78fd | 817 | // the host software, but isn't connected to any physical output. |
mjr | 35:e959ffba78fd | 818 | // This can be used for special software-only ports like the ZB |
mjr | 35:e959ffba78fd | 819 | // Launch Ball output, or simply for placeholders in the LedWiz port |
mjr | 35:e959ffba78fd | 820 | // numbering. |
mjr | 35:e959ffba78fd | 821 | class LwVirtualOut: public LwOut |
mjr | 33:d832bcab089e | 822 | { |
mjr | 33:d832bcab089e | 823 | public: |
mjr | 35:e959ffba78fd | 824 | LwVirtualOut() { } |
mjr | 40:cc0d9814522b | 825 | virtual void set(uint8_t ) { } |
mjr | 33:d832bcab089e | 826 | }; |
mjr | 26:cb71c4af2912 | 827 | |
mjr | 34:6b981a2afab7 | 828 | // Active Low out. For any output marked as active low, we layer this |
mjr | 34:6b981a2afab7 | 829 | // on top of the physical pin interface. This simply inverts the value of |
mjr | 40:cc0d9814522b | 830 | // the output value, so that 255 means fully off and 0 means fully on. |
mjr | 34:6b981a2afab7 | 831 | class LwInvertedOut: public LwOut |
mjr | 34:6b981a2afab7 | 832 | { |
mjr | 34:6b981a2afab7 | 833 | public: |
mjr | 34:6b981a2afab7 | 834 | LwInvertedOut(LwOut *o) : out(o) { } |
mjr | 40:cc0d9814522b | 835 | virtual void set(uint8_t val) { out->set(255 - val); } |
mjr | 34:6b981a2afab7 | 836 | |
mjr | 34:6b981a2afab7 | 837 | private: |
mjr | 53:9b2611964afc | 838 | // underlying physical output |
mjr | 34:6b981a2afab7 | 839 | LwOut *out; |
mjr | 34:6b981a2afab7 | 840 | }; |
mjr | 34:6b981a2afab7 | 841 | |
mjr | 53:9b2611964afc | 842 | // Global ZB Launch Ball state |
mjr | 53:9b2611964afc | 843 | bool zbLaunchOn = false; |
mjr | 53:9b2611964afc | 844 | |
mjr | 53:9b2611964afc | 845 | // ZB Launch Ball output. This is layered on a port (physical or virtual) |
mjr | 53:9b2611964afc | 846 | // to track the ZB Launch Ball signal. |
mjr | 53:9b2611964afc | 847 | class LwZbLaunchOut: public LwOut |
mjr | 53:9b2611964afc | 848 | { |
mjr | 53:9b2611964afc | 849 | public: |
mjr | 53:9b2611964afc | 850 | LwZbLaunchOut(LwOut *o) : out(o) { } |
mjr | 53:9b2611964afc | 851 | virtual void set(uint8_t val) |
mjr | 53:9b2611964afc | 852 | { |
mjr | 53:9b2611964afc | 853 | // update the global ZB Launch Ball state |
mjr | 53:9b2611964afc | 854 | zbLaunchOn = (val != 0); |
mjr | 53:9b2611964afc | 855 | |
mjr | 53:9b2611964afc | 856 | // pass it along to the underlying port, in case it's a physical output |
mjr | 53:9b2611964afc | 857 | out->set(val); |
mjr | 53:9b2611964afc | 858 | } |
mjr | 53:9b2611964afc | 859 | |
mjr | 53:9b2611964afc | 860 | private: |
mjr | 53:9b2611964afc | 861 | // underlying physical or virtual output |
mjr | 53:9b2611964afc | 862 | LwOut *out; |
mjr | 53:9b2611964afc | 863 | }; |
mjr | 53:9b2611964afc | 864 | |
mjr | 53:9b2611964afc | 865 | |
mjr | 40:cc0d9814522b | 866 | // Gamma correction table for 8-bit input values |
mjr | 87:8d35c74403af | 867 | static const uint8_t dof_to_gamma_8bit[] = { |
mjr | 40:cc0d9814522b | 868 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
mjr | 40:cc0d9814522b | 869 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, |
mjr | 40:cc0d9814522b | 870 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, |
mjr | 40:cc0d9814522b | 871 | 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, |
mjr | 40:cc0d9814522b | 872 | 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, |
mjr | 40:cc0d9814522b | 873 | 10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16, |
mjr | 40:cc0d9814522b | 874 | 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25, |
mjr | 40:cc0d9814522b | 875 | 25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36, |
mjr | 40:cc0d9814522b | 876 | 37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50, |
mjr | 40:cc0d9814522b | 877 | 51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68, |
mjr | 40:cc0d9814522b | 878 | 69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89, |
mjr | 40:cc0d9814522b | 879 | 90, 92, 93, 95, 96, 98, 99, 101, 102, 104, 105, 107, 109, 110, 112, 114, |
mjr | 40:cc0d9814522b | 880 | 115, 117, 119, 120, 122, 124, 126, 127, 129, 131, 133, 135, 137, 138, 140, 142, |
mjr | 40:cc0d9814522b | 881 | 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 167, 169, 171, 173, 175, |
mjr | 40:cc0d9814522b | 882 | 177, 180, 182, 184, 186, 189, 191, 193, 196, 198, 200, 203, 205, 208, 210, 213, |
mjr | 40:cc0d9814522b | 883 | 215, 218, 220, 223, 225, 228, 231, 233, 236, 239, 241, 244, 247, 249, 252, 255 |
mjr | 40:cc0d9814522b | 884 | }; |
mjr | 40:cc0d9814522b | 885 | |
mjr | 40:cc0d9814522b | 886 | // Gamma-corrected out. This is a filter object that we layer on top |
mjr | 40:cc0d9814522b | 887 | // of a physical pin interface. This applies gamma correction to the |
mjr | 40:cc0d9814522b | 888 | // input value and then passes it along to the underlying pin object. |
mjr | 40:cc0d9814522b | 889 | class LwGammaOut: public LwOut |
mjr | 40:cc0d9814522b | 890 | { |
mjr | 40:cc0d9814522b | 891 | public: |
mjr | 40:cc0d9814522b | 892 | LwGammaOut(LwOut *o) : out(o) { } |
mjr | 87:8d35c74403af | 893 | virtual void set(uint8_t val) { out->set(dof_to_gamma_8bit[val]); } |
mjr | 40:cc0d9814522b | 894 | |
mjr | 40:cc0d9814522b | 895 | private: |
mjr | 40:cc0d9814522b | 896 | LwOut *out; |
mjr | 40:cc0d9814522b | 897 | }; |
mjr | 40:cc0d9814522b | 898 | |
mjr | 77:0b96f6867312 | 899 | // Global night mode flag. To minimize overhead when reporting |
mjr | 77:0b96f6867312 | 900 | // the status, we set this to the status report flag bit for |
mjr | 77:0b96f6867312 | 901 | // night mode, 0x02, when engaged. |
mjr | 77:0b96f6867312 | 902 | static uint8_t nightMode = 0x00; |
mjr | 53:9b2611964afc | 903 | |
mjr | 40:cc0d9814522b | 904 | // Noisy output. This is a filter object that we layer on top of |
mjr | 40:cc0d9814522b | 905 | // a physical pin output. This filter disables the port when night |
mjr | 40:cc0d9814522b | 906 | // mode is engaged. |
mjr | 40:cc0d9814522b | 907 | class LwNoisyOut: public LwOut |
mjr | 40:cc0d9814522b | 908 | { |
mjr | 40:cc0d9814522b | 909 | public: |
mjr | 40:cc0d9814522b | 910 | LwNoisyOut(LwOut *o) : out(o) { } |
mjr | 40:cc0d9814522b | 911 | virtual void set(uint8_t val) { out->set(nightMode ? 0 : val); } |
mjr | 40:cc0d9814522b | 912 | |
mjr | 53:9b2611964afc | 913 | private: |
mjr | 53:9b2611964afc | 914 | LwOut *out; |
mjr | 53:9b2611964afc | 915 | }; |
mjr | 53:9b2611964afc | 916 | |
mjr | 53:9b2611964afc | 917 | // Night Mode indicator output. This is a filter object that we |
mjr | 53:9b2611964afc | 918 | // layer on top of a physical pin output. This filter ignores the |
mjr | 53:9b2611964afc | 919 | // host value and simply shows the night mode status. |
mjr | 53:9b2611964afc | 920 | class LwNightModeIndicatorOut: public LwOut |
mjr | 53:9b2611964afc | 921 | { |
mjr | 53:9b2611964afc | 922 | public: |
mjr | 53:9b2611964afc | 923 | LwNightModeIndicatorOut(LwOut *o) : out(o) { } |
mjr | 89:c43cd923401c | 924 | virtual void set(uint8_t) |
mjr | 53:9b2611964afc | 925 | { |
mjr | 53:9b2611964afc | 926 | // ignore the host value and simply show the current |
mjr | 53:9b2611964afc | 927 | // night mode setting |
mjr | 53:9b2611964afc | 928 | out->set(nightMode ? 255 : 0); |
mjr | 53:9b2611964afc | 929 | } |
mjr | 40:cc0d9814522b | 930 | |
mjr | 40:cc0d9814522b | 931 | private: |
mjr | 40:cc0d9814522b | 932 | LwOut *out; |
mjr | 40:cc0d9814522b | 933 | }; |
mjr | 40:cc0d9814522b | 934 | |
mjr | 26:cb71c4af2912 | 935 | |
mjr | 89:c43cd923401c | 936 | // Flipper Logic output. This is a filter object that we layer on |
mjr | 89:c43cd923401c | 937 | // top of a physical pin output. |
mjr | 89:c43cd923401c | 938 | // |
mjr | 89:c43cd923401c | 939 | // A Flipper Logic output is effectively a digital output from the |
mjr | 89:c43cd923401c | 940 | // client's perspective, in that it ignores the intensity level and |
mjr | 89:c43cd923401c | 941 | // only pays attention to the ON/OFF state. 0 is OFF and any other |
mjr | 89:c43cd923401c | 942 | // level is ON. |
mjr | 89:c43cd923401c | 943 | // |
mjr | 89:c43cd923401c | 944 | // In terms of the physical output, though, we do use varying power. |
mjr | 89:c43cd923401c | 945 | // It's just that the varying power isn't under the client's control; |
mjr | 89:c43cd923401c | 946 | // we control it according to our flipperLogic settings: |
mjr | 89:c43cd923401c | 947 | // |
mjr | 89:c43cd923401c | 948 | // - When the software port transitions from OFF (0 brightness) to ON |
mjr | 89:c43cd923401c | 949 | // (any non-zero brightness level), we set the physical port to 100% |
mjr | 89:c43cd923401c | 950 | // power and start a timer. |
mjr | 89:c43cd923401c | 951 | // |
mjr | 89:c43cd923401c | 952 | // - When the full power time in our flipperLogic settings elapses, |
mjr | 89:c43cd923401c | 953 | // if the software port is still ON, we reduce the physical port to |
mjr | 89:c43cd923401c | 954 | // the PWM level in our flipperLogic setting. |
mjr | 89:c43cd923401c | 955 | // |
mjr | 89:c43cd923401c | 956 | class LwFlipperLogicOut: public LwOut |
mjr | 89:c43cd923401c | 957 | { |
mjr | 89:c43cd923401c | 958 | public: |
mjr | 89:c43cd923401c | 959 | // Set up the output. 'params' is the flipperLogic value from |
mjr | 89:c43cd923401c | 960 | // the configuration. |
mjr | 89:c43cd923401c | 961 | LwFlipperLogicOut(LwOut *o, uint8_t params) |
mjr | 89:c43cd923401c | 962 | : out(o), params(params) |
mjr | 89:c43cd923401c | 963 | { |
mjr | 89:c43cd923401c | 964 | // initially OFF |
mjr | 89:c43cd923401c | 965 | state = 0; |
mjr | 89:c43cd923401c | 966 | } |
mjr | 89:c43cd923401c | 967 | |
mjr | 89:c43cd923401c | 968 | virtual void set(uint8_t level) |
mjr | 89:c43cd923401c | 969 | { |
mjr | 98:4df3c0f7e707 | 970 | // remember the new nominal level set by the client |
mjr | 89:c43cd923401c | 971 | val = level; |
mjr | 89:c43cd923401c | 972 | |
mjr | 89:c43cd923401c | 973 | // update the physical output according to our current timing state |
mjr | 89:c43cd923401c | 974 | switch (state) |
mjr | 89:c43cd923401c | 975 | { |
mjr | 89:c43cd923401c | 976 | case 0: |
mjr | 89:c43cd923401c | 977 | // We're currently off. If the new level is non-zero, switch |
mjr | 89:c43cd923401c | 978 | // to state 1 (initial full-power interval) and set the requested |
mjr | 89:c43cd923401c | 979 | // level. If the new level is zero, we're switching from off to |
mjr | 89:c43cd923401c | 980 | // off, so there's no change. |
mjr | 89:c43cd923401c | 981 | if (level != 0) |
mjr | 89:c43cd923401c | 982 | { |
mjr | 89:c43cd923401c | 983 | // switch to state 1 (initial full-power interval) |
mjr | 89:c43cd923401c | 984 | state = 1; |
mjr | 89:c43cd923401c | 985 | |
mjr | 89:c43cd923401c | 986 | // set the requested output level - there's no limit during |
mjr | 89:c43cd923401c | 987 | // the initial full-power interval, so set the exact level |
mjr | 89:c43cd923401c | 988 | // requested |
mjr | 89:c43cd923401c | 989 | out->set(level); |
mjr | 89:c43cd923401c | 990 | |
mjr | 89:c43cd923401c | 991 | // add myself to the pending timer list |
mjr | 89:c43cd923401c | 992 | pending[nPending++] = this; |
mjr | 89:c43cd923401c | 993 | |
mjr | 89:c43cd923401c | 994 | // note the starting time |
mjr | 89:c43cd923401c | 995 | t0 = timer.read_us(); |
mjr | 89:c43cd923401c | 996 | } |
mjr | 89:c43cd923401c | 997 | break; |
mjr | 89:c43cd923401c | 998 | |
mjr | 89:c43cd923401c | 999 | case 1: |
mjr | 89:c43cd923401c | 1000 | // Initial full-power interval. If the new level is non-zero, |
mjr | 89:c43cd923401c | 1001 | // simply apply the new level as requested, since there's no |
mjr | 89:c43cd923401c | 1002 | // limit during this period. If the new level is zero, shut |
mjr | 89:c43cd923401c | 1003 | // off the output and cancel the pending timer. |
mjr | 89:c43cd923401c | 1004 | out->set(level); |
mjr | 89:c43cd923401c | 1005 | if (level == 0) |
mjr | 89:c43cd923401c | 1006 | { |
mjr | 89:c43cd923401c | 1007 | // We're switching off. In state 1, we have a pending timer, |
mjr | 89:c43cd923401c | 1008 | // so we need to remove it from the list. |
mjr | 89:c43cd923401c | 1009 | for (int i = 0 ; i < nPending ; ++i) |
mjr | 89:c43cd923401c | 1010 | { |
mjr | 89:c43cd923401c | 1011 | // is this us? |
mjr | 89:c43cd923401c | 1012 | if (pending[i] == this) |
mjr | 89:c43cd923401c | 1013 | { |
mjr | 89:c43cd923401c | 1014 | // remove myself by replacing the slot with the |
mjr | 89:c43cd923401c | 1015 | // last list entry |
mjr | 89:c43cd923401c | 1016 | pending[i] = pending[--nPending]; |
mjr | 89:c43cd923401c | 1017 | |
mjr | 89:c43cd923401c | 1018 | // no need to look any further |
mjr | 89:c43cd923401c | 1019 | break; |
mjr | 89:c43cd923401c | 1020 | } |
mjr | 89:c43cd923401c | 1021 | } |
mjr | 89:c43cd923401c | 1022 | |
mjr | 89:c43cd923401c | 1023 | // switch to state 0 (off) |
mjr | 89:c43cd923401c | 1024 | state = 0; |
mjr | 89:c43cd923401c | 1025 | } |
mjr | 89:c43cd923401c | 1026 | break; |
mjr | 89:c43cd923401c | 1027 | |
mjr | 89:c43cd923401c | 1028 | case 2: |
mjr | 89:c43cd923401c | 1029 | // Hold interval. If the new level is zero, switch to state |
mjr | 89:c43cd923401c | 1030 | // 0 (off). If the new level is non-zero, stay in the hold |
mjr | 89:c43cd923401c | 1031 | // state, and set the new level, applying the hold power setting |
mjr | 89:c43cd923401c | 1032 | // as the upper bound. |
mjr | 89:c43cd923401c | 1033 | if (level == 0) |
mjr | 89:c43cd923401c | 1034 | { |
mjr | 89:c43cd923401c | 1035 | // switching off - turn off the physical output |
mjr | 89:c43cd923401c | 1036 | out->set(0); |
mjr | 89:c43cd923401c | 1037 | |
mjr | 89:c43cd923401c | 1038 | // go to state 0 (off) |
mjr | 89:c43cd923401c | 1039 | state = 0; |
mjr | 89:c43cd923401c | 1040 | } |
mjr | 89:c43cd923401c | 1041 | else |
mjr | 89:c43cd923401c | 1042 | { |
mjr | 89:c43cd923401c | 1043 | // staying on - set the new physical output power to the |
mjr | 89:c43cd923401c | 1044 | // lower of the requested power and the hold power |
mjr | 89:c43cd923401c | 1045 | uint8_t hold = holdPower(); |
mjr | 89:c43cd923401c | 1046 | out->set(level < hold ? level : hold); |
mjr | 89:c43cd923401c | 1047 | } |
mjr | 89:c43cd923401c | 1048 | break; |
mjr | 89:c43cd923401c | 1049 | } |
mjr | 89:c43cd923401c | 1050 | } |
mjr | 89:c43cd923401c | 1051 | |
mjr | 89:c43cd923401c | 1052 | // Class initialization |
mjr | 89:c43cd923401c | 1053 | static void classInit(Config &cfg) |
mjr | 89:c43cd923401c | 1054 | { |
mjr | 89:c43cd923401c | 1055 | // Count the Flipper Logic outputs in the configuration. We |
mjr | 89:c43cd923401c | 1056 | // need to allocate enough pending timer list space to accommodate |
mjr | 89:c43cd923401c | 1057 | // all of these outputs. |
mjr | 89:c43cd923401c | 1058 | int n = 0; |
mjr | 89:c43cd923401c | 1059 | for (int i = 0 ; i < MAX_OUT_PORTS ; ++i) |
mjr | 89:c43cd923401c | 1060 | { |
mjr | 89:c43cd923401c | 1061 | // if this port is active and marked as Flipper Logic, count it |
mjr | 89:c43cd923401c | 1062 | if (cfg.outPort[i].typ != PortTypeDisabled |
mjr | 89:c43cd923401c | 1063 | && (cfg.outPort[i].flags & PortFlagFlipperLogic) != 0) |
mjr | 89:c43cd923401c | 1064 | ++n; |
mjr | 89:c43cd923401c | 1065 | } |
mjr | 89:c43cd923401c | 1066 | |
mjr | 89:c43cd923401c | 1067 | // allocate space for the pending timer list |
mjr | 89:c43cd923401c | 1068 | pending = new LwFlipperLogicOut*[n]; |
mjr | 89:c43cd923401c | 1069 | |
mjr | 89:c43cd923401c | 1070 | // there's nothing in the pending list yet |
mjr | 89:c43cd923401c | 1071 | nPending = 0; |
mjr | 89:c43cd923401c | 1072 | |
mjr | 89:c43cd923401c | 1073 | // Start our shared timer. The epoch is arbitrary, since we only |
mjr | 89:c43cd923401c | 1074 | // use it to figure elapsed times. |
mjr | 89:c43cd923401c | 1075 | timer.start(); |
mjr | 89:c43cd923401c | 1076 | } |
mjr | 89:c43cd923401c | 1077 | |
mjr | 89:c43cd923401c | 1078 | // Check for ports with pending timers. The main routine should |
mjr | 89:c43cd923401c | 1079 | // call this on each iteration to process our state transitions. |
mjr | 89:c43cd923401c | 1080 | static void poll() |
mjr | 89:c43cd923401c | 1081 | { |
mjr | 89:c43cd923401c | 1082 | // note the current time |
mjr | 89:c43cd923401c | 1083 | uint32_t t = timer.read_us(); |
mjr | 89:c43cd923401c | 1084 | |
mjr | 89:c43cd923401c | 1085 | // go through the timer list |
mjr | 89:c43cd923401c | 1086 | for (int i = 0 ; i < nPending ; ) |
mjr | 89:c43cd923401c | 1087 | { |
mjr | 89:c43cd923401c | 1088 | // get the port |
mjr | 89:c43cd923401c | 1089 | LwFlipperLogicOut *port = pending[i]; |
mjr | 89:c43cd923401c | 1090 | |
mjr | 89:c43cd923401c | 1091 | // assume we'll keep it |
mjr | 89:c43cd923401c | 1092 | bool remove = false; |
mjr | 89:c43cd923401c | 1093 | |
mjr | 89:c43cd923401c | 1094 | // check if the port is still on |
mjr | 89:c43cd923401c | 1095 | if (port->state != 0) |
mjr | 89:c43cd923401c | 1096 | { |
mjr | 89:c43cd923401c | 1097 | // it's still on - check if the initial full power time has elapsed |
mjr | 89:c43cd923401c | 1098 | if (uint32_t(t - port->t0) > port->fullPowerTime_us()) |
mjr | 89:c43cd923401c | 1099 | { |
mjr | 89:c43cd923401c | 1100 | // done with the full power interval - switch to hold state |
mjr | 89:c43cd923401c | 1101 | port->state = 2; |
mjr | 89:c43cd923401c | 1102 | |
mjr | 89:c43cd923401c | 1103 | // set the physical port to the hold power setting or the |
mjr | 89:c43cd923401c | 1104 | // client brightness setting, whichever is lower |
mjr | 89:c43cd923401c | 1105 | uint8_t hold = port->holdPower(); |
mjr | 89:c43cd923401c | 1106 | uint8_t val = port->val; |
mjr | 89:c43cd923401c | 1107 | port->out->set(val < hold ? val : hold); |
mjr | 89:c43cd923401c | 1108 | |
mjr | 89:c43cd923401c | 1109 | // we're done with the timer |
mjr | 89:c43cd923401c | 1110 | remove = true; |
mjr | 89:c43cd923401c | 1111 | } |
mjr | 89:c43cd923401c | 1112 | } |
mjr | 89:c43cd923401c | 1113 | else |
mjr | 89:c43cd923401c | 1114 | { |
mjr | 89:c43cd923401c | 1115 | // the port was turned off before the timer expired - remove |
mjr | 89:c43cd923401c | 1116 | // it from the timer list |
mjr | 89:c43cd923401c | 1117 | remove = true; |
mjr | 89:c43cd923401c | 1118 | } |
mjr | 89:c43cd923401c | 1119 | |
mjr | 89:c43cd923401c | 1120 | // if desired, remove the port from the timer list |
mjr | 89:c43cd923401c | 1121 | if (remove) |
mjr | 89:c43cd923401c | 1122 | { |
mjr | 89:c43cd923401c | 1123 | // Remove the list entry by overwriting the slot with |
mjr | 89:c43cd923401c | 1124 | // the last entry in the list. |
mjr | 89:c43cd923401c | 1125 | pending[i] = pending[--nPending]; |
mjr | 89:c43cd923401c | 1126 | |
mjr | 89:c43cd923401c | 1127 | // Note that we don't increment the loop counter, since |
mjr | 89:c43cd923401c | 1128 | // we now need to revisit this same slot. |
mjr | 89:c43cd923401c | 1129 | } |
mjr | 89:c43cd923401c | 1130 | else |
mjr | 89:c43cd923401c | 1131 | { |
mjr | 89:c43cd923401c | 1132 | // we're keeping this item; move on to the next one |
mjr | 89:c43cd923401c | 1133 | ++i; |
mjr | 89:c43cd923401c | 1134 | } |
mjr | 89:c43cd923401c | 1135 | } |
mjr | 89:c43cd923401c | 1136 | } |
mjr | 89:c43cd923401c | 1137 | |
mjr | 89:c43cd923401c | 1138 | protected: |
mjr | 89:c43cd923401c | 1139 | // underlying physical output |
mjr | 89:c43cd923401c | 1140 | LwOut *out; |
mjr | 89:c43cd923401c | 1141 | |
mjr | 89:c43cd923401c | 1142 | // Timestamp on 'timer' of start of full-power interval. We set this |
mjr | 89:c43cd923401c | 1143 | // to the current 'timer' timestamp when entering state 1. |
mjr | 89:c43cd923401c | 1144 | uint32_t t0; |
mjr | 89:c43cd923401c | 1145 | |
mjr | 89:c43cd923401c | 1146 | // Nominal output level (brightness) last set by the client. During |
mjr | 89:c43cd923401c | 1147 | // the initial full-power interval, we replicate the requested level |
mjr | 89:c43cd923401c | 1148 | // exactly on the physical output. During the hold interval, we limit |
mjr | 89:c43cd923401c | 1149 | // the physical output to the hold power, but use the caller's value |
mjr | 89:c43cd923401c | 1150 | // if it's lower. |
mjr | 89:c43cd923401c | 1151 | uint8_t val; |
mjr | 89:c43cd923401c | 1152 | |
mjr | 89:c43cd923401c | 1153 | // Current port state: |
mjr | 89:c43cd923401c | 1154 | // |
mjr | 89:c43cd923401c | 1155 | // 0 = off |
mjr | 89:c43cd923401c | 1156 | // 1 = on at initial full power |
mjr | 89:c43cd923401c | 1157 | // 2 = on at hold power |
mjr | 89:c43cd923401c | 1158 | uint8_t state; |
mjr | 89:c43cd923401c | 1159 | |
mjr | 89:c43cd923401c | 1160 | // Configuration parameters. The high 4 bits encode the initial full- |
mjr | 89:c43cd923401c | 1161 | // power time in 50ms units, starting at 0=50ms. The low 4 bits encode |
mjr | 89:c43cd923401c | 1162 | // the hold power (applied after the initial time expires if the output |
mjr | 89:c43cd923401c | 1163 | // is still on) in units of 6.66%. The resulting percentage is used |
mjr | 89:c43cd923401c | 1164 | // for the PWM duty cycle of the physical output. |
mjr | 89:c43cd923401c | 1165 | uint8_t params; |
mjr | 89:c43cd923401c | 1166 | |
mjr | 99:8139b0c274f4 | 1167 | // Figure the initial full-power time in microseconds: 50ms * (1+N), |
mjr | 99:8139b0c274f4 | 1168 | // where N is the high 4 bits of the parameter byte. |
mjr | 99:8139b0c274f4 | 1169 | inline uint32_t fullPowerTime_us() const { return 50000*(1 + ((params >> 4) & 0x0F)); } |
mjr | 89:c43cd923401c | 1170 | |
mjr | 89:c43cd923401c | 1171 | // Figure the hold power PWM level (0-255) |
mjr | 89:c43cd923401c | 1172 | inline uint8_t holdPower() const { return (params & 0x0F) * 17; } |
mjr | 89:c43cd923401c | 1173 | |
mjr | 89:c43cd923401c | 1174 | // Timer. This is a shared timer for all of the FL ports. When we |
mjr | 89:c43cd923401c | 1175 | // transition from OFF to ON, we note the current time on this timer |
mjr | 89:c43cd923401c | 1176 | // (which runs continuously). |
mjr | 89:c43cd923401c | 1177 | static Timer timer; |
mjr | 89:c43cd923401c | 1178 | |
mjr | 89:c43cd923401c | 1179 | // Flipper logic pending timer list. Whenever a flipper logic output |
mjr | 98:4df3c0f7e707 | 1180 | // transitions from OFF to ON, we add it to this list. We scan the |
mjr | 98:4df3c0f7e707 | 1181 | // list in our polling routine to find ports that have reached the |
mjr | 98:4df3c0f7e707 | 1182 | // expiration of their initial full-power intervals. |
mjr | 89:c43cd923401c | 1183 | static LwFlipperLogicOut **pending; |
mjr | 89:c43cd923401c | 1184 | static uint8_t nPending; |
mjr | 89:c43cd923401c | 1185 | }; |
mjr | 89:c43cd923401c | 1186 | |
mjr | 89:c43cd923401c | 1187 | // Flipper Logic statics |
mjr | 89:c43cd923401c | 1188 | Timer LwFlipperLogicOut::timer; |
mjr | 89:c43cd923401c | 1189 | LwFlipperLogicOut **LwFlipperLogicOut::pending; |
mjr | 89:c43cd923401c | 1190 | uint8_t LwFlipperLogicOut::nPending; |
mjr | 99:8139b0c274f4 | 1191 | |
mjr | 99:8139b0c274f4 | 1192 | // Chime Logic. This is a filter output that we layer on a physical |
mjr | 99:8139b0c274f4 | 1193 | // output to set a minimum and maximum ON time for the output. |
mjr | 99:8139b0c274f4 | 1194 | class LwChimeLogicOut: public LwOut |
mjr | 98:4df3c0f7e707 | 1195 | { |
mjr | 98:4df3c0f7e707 | 1196 | public: |
mjr | 99:8139b0c274f4 | 1197 | // Set up the output. 'params' encodes the minimum and maximum time. |
mjr | 99:8139b0c274f4 | 1198 | LwChimeLogicOut(LwOut *o, uint8_t params) |
mjr | 99:8139b0c274f4 | 1199 | : out(o), params(params) |
mjr | 98:4df3c0f7e707 | 1200 | { |
mjr | 98:4df3c0f7e707 | 1201 | // initially OFF |
mjr | 98:4df3c0f7e707 | 1202 | state = 0; |
mjr | 98:4df3c0f7e707 | 1203 | } |
mjr | 98:4df3c0f7e707 | 1204 | |
mjr | 98:4df3c0f7e707 | 1205 | virtual void set(uint8_t level) |
mjr | 98:4df3c0f7e707 | 1206 | { |
mjr | 98:4df3c0f7e707 | 1207 | // update the physical output according to our current timing state |
mjr | 98:4df3c0f7e707 | 1208 | switch (state) |
mjr | 98:4df3c0f7e707 | 1209 | { |
mjr | 98:4df3c0f7e707 | 1210 | case 0: |
mjr | 98:4df3c0f7e707 | 1211 | // We're currently off. If the new level is non-zero, switch |
mjr | 98:4df3c0f7e707 | 1212 | // to state 1 (initial minimum interval) and set the requested |
mjr | 98:4df3c0f7e707 | 1213 | // level. If the new level is zero, we're switching from off to |
mjr | 98:4df3c0f7e707 | 1214 | // off, so there's no change. |
mjr | 98:4df3c0f7e707 | 1215 | if (level != 0) |
mjr | 98:4df3c0f7e707 | 1216 | { |
mjr | 98:4df3c0f7e707 | 1217 | // switch to state 1 (initial minimum interval, port is |
mjr | 98:4df3c0f7e707 | 1218 | // logically on) |
mjr | 98:4df3c0f7e707 | 1219 | state = 1; |
mjr | 98:4df3c0f7e707 | 1220 | |
mjr | 98:4df3c0f7e707 | 1221 | // set the requested output level |
mjr | 98:4df3c0f7e707 | 1222 | out->set(level); |
mjr | 98:4df3c0f7e707 | 1223 | |
mjr | 98:4df3c0f7e707 | 1224 | // add myself to the pending timer list |
mjr | 98:4df3c0f7e707 | 1225 | pending[nPending++] = this; |
mjr | 98:4df3c0f7e707 | 1226 | |
mjr | 98:4df3c0f7e707 | 1227 | // note the starting time |
mjr | 98:4df3c0f7e707 | 1228 | t0 = timer.read_us(); |
mjr | 98:4df3c0f7e707 | 1229 | } |
mjr | 98:4df3c0f7e707 | 1230 | break; |
mjr | 98:4df3c0f7e707 | 1231 | |
mjr | 98:4df3c0f7e707 | 1232 | case 1: // min ON interval, port on |
mjr | 98:4df3c0f7e707 | 1233 | case 2: // min ON interval, port off |
mjr | 98:4df3c0f7e707 | 1234 | // We're in the initial minimum ON interval. If the new power |
mjr | 98:4df3c0f7e707 | 1235 | // level is non-zero, pass it through to the physical port, since |
mjr | 98:4df3c0f7e707 | 1236 | // the client is allowed to change the power level during the |
mjr | 98:4df3c0f7e707 | 1237 | // initial ON interval - they just can't turn it off entirely. |
mjr | 98:4df3c0f7e707 | 1238 | // Set the state to 1 to indicate that the logical port is on. |
mjr | 98:4df3c0f7e707 | 1239 | // |
mjr | 98:4df3c0f7e707 | 1240 | // If the new level is zero, leave the underlying port at its |
mjr | 98:4df3c0f7e707 | 1241 | // current power level, since we're not allowed to turn it off |
mjr | 98:4df3c0f7e707 | 1242 | // during this period. Set the state to 2 to indicate that the |
mjr | 98:4df3c0f7e707 | 1243 | // logical port is off even though the physical port has to stay |
mjr | 98:4df3c0f7e707 | 1244 | // on for the remainder of the interval. |
mjr | 98:4df3c0f7e707 | 1245 | if (level != 0) |
mjr | 98:4df3c0f7e707 | 1246 | { |
mjr | 98:4df3c0f7e707 | 1247 | // client is leaving the port on - pass through the new |
mjr | 98:4df3c0f7e707 | 1248 | // power level and set state 1 (logically on) |
mjr | 98:4df3c0f7e707 | 1249 | out->set(level); |
mjr | 98:4df3c0f7e707 | 1250 | state = 1; |
mjr | 98:4df3c0f7e707 | 1251 | } |
mjr | 98:4df3c0f7e707 | 1252 | else |
mjr | 98:4df3c0f7e707 | 1253 | { |
mjr | 98:4df3c0f7e707 | 1254 | // Client is turning off the port - leave the underlying port |
mjr | 98:4df3c0f7e707 | 1255 | // on at its current level and set state 2 (logically off). |
mjr | 98:4df3c0f7e707 | 1256 | // When the minimum ON time expires, the polling routine will |
mjr | 98:4df3c0f7e707 | 1257 | // see that we're logically off and will pass that through to |
mjr | 98:4df3c0f7e707 | 1258 | // the underlying physical port. Until then, though, we have |
mjr | 98:4df3c0f7e707 | 1259 | // to leave the physical port on to satisfy the minimum ON |
mjr | 98:4df3c0f7e707 | 1260 | // time requirement. |
mjr | 98:4df3c0f7e707 | 1261 | state = 2; |
mjr | 98:4df3c0f7e707 | 1262 | } |
mjr | 98:4df3c0f7e707 | 1263 | break; |
mjr | 98:4df3c0f7e707 | 1264 | |
mjr | 98:4df3c0f7e707 | 1265 | case 3: |
mjr | 99:8139b0c274f4 | 1266 | // We're after the minimum ON interval and before the maximum |
mjr | 99:8139b0c274f4 | 1267 | // ON time limit. We can set any new level, including fully off. |
mjr | 99:8139b0c274f4 | 1268 | // Pass the new power level through to the port. |
mjr | 98:4df3c0f7e707 | 1269 | out->set(level); |
mjr | 98:4df3c0f7e707 | 1270 | |
mjr | 98:4df3c0f7e707 | 1271 | // if the port is now off, return to state 0 (OFF) |
mjr | 98:4df3c0f7e707 | 1272 | if (level == 0) |
mjr | 99:8139b0c274f4 | 1273 | { |
mjr | 99:8139b0c274f4 | 1274 | // return to the OFF state |
mjr | 99:8139b0c274f4 | 1275 | state = 0; |
mjr | 99:8139b0c274f4 | 1276 | |
mjr | 99:8139b0c274f4 | 1277 | // If we have a timer pending, remove it. A timer will be |
mjr | 99:8139b0c274f4 | 1278 | // pending if we have a non-infinite maximum on time for the |
mjr | 99:8139b0c274f4 | 1279 | // port. |
mjr | 99:8139b0c274f4 | 1280 | for (int i = 0 ; i < nPending ; ++i) |
mjr | 99:8139b0c274f4 | 1281 | { |
mjr | 99:8139b0c274f4 | 1282 | // is this us? |
mjr | 99:8139b0c274f4 | 1283 | if (pending[i] == this) |
mjr | 99:8139b0c274f4 | 1284 | { |
mjr | 99:8139b0c274f4 | 1285 | // remove myself by replacing the slot with the |
mjr | 99:8139b0c274f4 | 1286 | // last list entry |
mjr | 99:8139b0c274f4 | 1287 | pending[i] = pending[--nPending]; |
mjr | 99:8139b0c274f4 | 1288 | |
mjr | 99:8139b0c274f4 | 1289 | // no need to look any further |
mjr | 99:8139b0c274f4 | 1290 | break; |
mjr | 99:8139b0c274f4 | 1291 | } |
mjr | 99:8139b0c274f4 | 1292 | } |
mjr | 99:8139b0c274f4 | 1293 | } |
mjr | 99:8139b0c274f4 | 1294 | break; |
mjr | 99:8139b0c274f4 | 1295 | |
mjr | 99:8139b0c274f4 | 1296 | case 4: |
mjr | 99:8139b0c274f4 | 1297 | // We're after the maximum ON time. The physical port stays off |
mjr | 99:8139b0c274f4 | 1298 | // during this interval, so we don't pass any changes through to |
mjr | 99:8139b0c274f4 | 1299 | // the physical port. When the client sets the level to 0, we |
mjr | 99:8139b0c274f4 | 1300 | // turn off the logical port and reset to state 0. |
mjr | 99:8139b0c274f4 | 1301 | if (level == 0) |
mjr | 98:4df3c0f7e707 | 1302 | state = 0; |
mjr | 98:4df3c0f7e707 | 1303 | break; |
mjr | 98:4df3c0f7e707 | 1304 | } |
mjr | 98:4df3c0f7e707 | 1305 | } |
mjr | 98:4df3c0f7e707 | 1306 | |
mjr | 98:4df3c0f7e707 | 1307 | // Class initialization |
mjr | 98:4df3c0f7e707 | 1308 | static void classInit(Config &cfg) |
mjr | 98:4df3c0f7e707 | 1309 | { |
mjr | 98:4df3c0f7e707 | 1310 | // Count the Minimum On Time outputs in the configuration. We |
mjr | 98:4df3c0f7e707 | 1311 | // need to allocate enough pending timer list space to accommodate |
mjr | 98:4df3c0f7e707 | 1312 | // all of these outputs. |
mjr | 98:4df3c0f7e707 | 1313 | int n = 0; |
mjr | 98:4df3c0f7e707 | 1314 | for (int i = 0 ; i < MAX_OUT_PORTS ; ++i) |
mjr | 98:4df3c0f7e707 | 1315 | { |
mjr | 98:4df3c0f7e707 | 1316 | // if this port is active and marked as Flipper Logic, count it |
mjr | 98:4df3c0f7e707 | 1317 | if (cfg.outPort[i].typ != PortTypeDisabled |
mjr | 99:8139b0c274f4 | 1318 | && (cfg.outPort[i].flags & PortFlagChimeLogic) != 0) |
mjr | 98:4df3c0f7e707 | 1319 | ++n; |
mjr | 98:4df3c0f7e707 | 1320 | } |
mjr | 98:4df3c0f7e707 | 1321 | |
mjr | 98:4df3c0f7e707 | 1322 | // allocate space for the pending timer list |
mjr | 99:8139b0c274f4 | 1323 | pending = new LwChimeLogicOut*[n]; |
mjr | 98:4df3c0f7e707 | 1324 | |
mjr | 98:4df3c0f7e707 | 1325 | // there's nothing in the pending list yet |
mjr | 98:4df3c0f7e707 | 1326 | nPending = 0; |
mjr | 98:4df3c0f7e707 | 1327 | |
mjr | 98:4df3c0f7e707 | 1328 | // Start our shared timer. The epoch is arbitrary, since we only |
mjr | 98:4df3c0f7e707 | 1329 | // use it to figure elapsed times. |
mjr | 98:4df3c0f7e707 | 1330 | timer.start(); |
mjr | 98:4df3c0f7e707 | 1331 | } |
mjr | 98:4df3c0f7e707 | 1332 | |
mjr | 98:4df3c0f7e707 | 1333 | // Check for ports with pending timers. The main routine should |
mjr | 98:4df3c0f7e707 | 1334 | // call this on each iteration to process our state transitions. |
mjr | 98:4df3c0f7e707 | 1335 | static void poll() |
mjr | 98:4df3c0f7e707 | 1336 | { |
mjr | 98:4df3c0f7e707 | 1337 | // note the current time |
mjr | 98:4df3c0f7e707 | 1338 | uint32_t t = timer.read_us(); |
mjr | 98:4df3c0f7e707 | 1339 | |
mjr | 98:4df3c0f7e707 | 1340 | // go through the timer list |
mjr | 98:4df3c0f7e707 | 1341 | for (int i = 0 ; i < nPending ; ) |
mjr | 98:4df3c0f7e707 | 1342 | { |
mjr | 98:4df3c0f7e707 | 1343 | // get the port |
mjr | 99:8139b0c274f4 | 1344 | LwChimeLogicOut *port = pending[i]; |
mjr | 98:4df3c0f7e707 | 1345 | |
mjr | 98:4df3c0f7e707 | 1346 | // assume we'll keep it |
mjr | 98:4df3c0f7e707 | 1347 | bool remove = false; |
mjr | 98:4df3c0f7e707 | 1348 | |
mjr | 99:8139b0c274f4 | 1349 | // check our state |
mjr | 99:8139b0c274f4 | 1350 | switch (port->state) |
mjr | 98:4df3c0f7e707 | 1351 | { |
mjr | 99:8139b0c274f4 | 1352 | case 1: // initial minimum ON time, port logically on |
mjr | 99:8139b0c274f4 | 1353 | case 2: // initial minimum ON time, port logically off |
mjr | 99:8139b0c274f4 | 1354 | // check if the minimum ON time has elapsed |
mjr | 98:4df3c0f7e707 | 1355 | if (uint32_t(t - port->t0) > port->minOnTime_us()) |
mjr | 98:4df3c0f7e707 | 1356 | { |
mjr | 98:4df3c0f7e707 | 1357 | // This port has completed its initial ON interval, so |
mjr | 98:4df3c0f7e707 | 1358 | // it advances to the next state. |
mjr | 98:4df3c0f7e707 | 1359 | if (port->state == 1) |
mjr | 98:4df3c0f7e707 | 1360 | { |
mjr | 99:8139b0c274f4 | 1361 | // The port is logically on, so advance to state 3. |
mjr | 99:8139b0c274f4 | 1362 | // The underlying port is already at its proper level, |
mjr | 99:8139b0c274f4 | 1363 | // since we pass through non-zero power settings to the |
mjr | 99:8139b0c274f4 | 1364 | // underlying port throughout the initial minimum time. |
mjr | 99:8139b0c274f4 | 1365 | // The timer stays active into state 3. |
mjr | 98:4df3c0f7e707 | 1366 | port->state = 3; |
mjr | 99:8139b0c274f4 | 1367 | |
mjr | 99:8139b0c274f4 | 1368 | // Special case: maximum on time 0 means "infinite". |
mjr | 99:8139b0c274f4 | 1369 | // There's no need for a timer in this case; we'll |
mjr | 99:8139b0c274f4 | 1370 | // just stay in state 3 until the client turns the |
mjr | 99:8139b0c274f4 | 1371 | // port off. |
mjr | 99:8139b0c274f4 | 1372 | if (port->maxOnTime_us() == 0) |
mjr | 99:8139b0c274f4 | 1373 | remove = true; |
mjr | 98:4df3c0f7e707 | 1374 | } |
mjr | 98:4df3c0f7e707 | 1375 | else |
mjr | 98:4df3c0f7e707 | 1376 | { |
mjr | 98:4df3c0f7e707 | 1377 | // The port was switched off by the client during the |
mjr | 98:4df3c0f7e707 | 1378 | // minimum ON period. We haven't passed the OFF state |
mjr | 98:4df3c0f7e707 | 1379 | // to the underlying port yet, because the port has to |
mjr | 98:4df3c0f7e707 | 1380 | // stay on throughout the minimum ON period. So turn |
mjr | 98:4df3c0f7e707 | 1381 | // the port off now. |
mjr | 98:4df3c0f7e707 | 1382 | port->out->set(0); |
mjr | 98:4df3c0f7e707 | 1383 | |
mjr | 98:4df3c0f7e707 | 1384 | // return to state 0 (OFF) |
mjr | 98:4df3c0f7e707 | 1385 | port->state = 0; |
mjr | 99:8139b0c274f4 | 1386 | |
mjr | 99:8139b0c274f4 | 1387 | // we're done with the timer |
mjr | 99:8139b0c274f4 | 1388 | remove = true; |
mjr | 98:4df3c0f7e707 | 1389 | } |
mjr | 99:8139b0c274f4 | 1390 | } |
mjr | 99:8139b0c274f4 | 1391 | break; |
mjr | 99:8139b0c274f4 | 1392 | |
mjr | 99:8139b0c274f4 | 1393 | case 3: // between minimum ON time and maximum ON time |
mjr | 99:8139b0c274f4 | 1394 | // check if the maximum ON time has expired |
mjr | 99:8139b0c274f4 | 1395 | if (uint32_t(t - port->t0) > port->maxOnTime_us()) |
mjr | 99:8139b0c274f4 | 1396 | { |
mjr | 99:8139b0c274f4 | 1397 | // The maximum ON time has expired. Turn off the physical |
mjr | 99:8139b0c274f4 | 1398 | // port. |
mjr | 99:8139b0c274f4 | 1399 | port->out->set(0); |
mjr | 98:4df3c0f7e707 | 1400 | |
mjr | 99:8139b0c274f4 | 1401 | // Switch to state 4 (logically ON past maximum time) |
mjr | 99:8139b0c274f4 | 1402 | port->state = 4; |
mjr | 99:8139b0c274f4 | 1403 | |
mjr | 99:8139b0c274f4 | 1404 | // Remove the timer on this port. This port simply stays |
mjr | 99:8139b0c274f4 | 1405 | // in state 4 until the client turns off the port. |
mjr | 98:4df3c0f7e707 | 1406 | remove = true; |
mjr | 98:4df3c0f7e707 | 1407 | } |
mjr | 99:8139b0c274f4 | 1408 | break; |
mjr | 98:4df3c0f7e707 | 1409 | } |
mjr | 98:4df3c0f7e707 | 1410 | |
mjr | 98:4df3c0f7e707 | 1411 | // if desired, remove the port from the timer list |
mjr | 98:4df3c0f7e707 | 1412 | if (remove) |
mjr | 98:4df3c0f7e707 | 1413 | { |
mjr | 98:4df3c0f7e707 | 1414 | // Remove the list entry by overwriting the slot with |
mjr | 98:4df3c0f7e707 | 1415 | // the last entry in the list. |
mjr | 98:4df3c0f7e707 | 1416 | pending[i] = pending[--nPending]; |
mjr | 98:4df3c0f7e707 | 1417 | |
mjr | 98:4df3c0f7e707 | 1418 | // Note that we don't increment the loop counter, since |
mjr | 98:4df3c0f7e707 | 1419 | // we now need to revisit this same slot. |
mjr | 98:4df3c0f7e707 | 1420 | } |
mjr | 98:4df3c0f7e707 | 1421 | else |
mjr | 98:4df3c0f7e707 | 1422 | { |
mjr | 98:4df3c0f7e707 | 1423 | // we're keeping this item; move on to the next one |
mjr | 98:4df3c0f7e707 | 1424 | ++i; |
mjr | 98:4df3c0f7e707 | 1425 | } |
mjr | 98:4df3c0f7e707 | 1426 | } |
mjr | 98:4df3c0f7e707 | 1427 | } |
mjr | 98:4df3c0f7e707 | 1428 | |
mjr | 98:4df3c0f7e707 | 1429 | protected: |
mjr | 98:4df3c0f7e707 | 1430 | // underlying physical output |
mjr | 98:4df3c0f7e707 | 1431 | LwOut *out; |
mjr | 98:4df3c0f7e707 | 1432 | |
mjr | 98:4df3c0f7e707 | 1433 | // Timestamp on 'timer' of start of full-power interval. We set this |
mjr | 98:4df3c0f7e707 | 1434 | // to the current 'timer' timestamp when entering state 1. |
mjr | 98:4df3c0f7e707 | 1435 | uint32_t t0; |
mjr | 98:4df3c0f7e707 | 1436 | |
mjr | 98:4df3c0f7e707 | 1437 | // Current port state: |
mjr | 98:4df3c0f7e707 | 1438 | // |
mjr | 98:4df3c0f7e707 | 1439 | // 0 = off |
mjr | 99:8139b0c274f4 | 1440 | // 1 = in initial minimum ON interval, logical port is on |
mjr | 99:8139b0c274f4 | 1441 | // 2 = in initial minimum ON interval, logical port is off |
mjr | 99:8139b0c274f4 | 1442 | // 3 = in interval between minimum and maximum ON times |
mjr | 99:8139b0c274f4 | 1443 | // 4 = after the maximum ON interval |
mjr | 99:8139b0c274f4 | 1444 | // |
mjr | 99:8139b0c274f4 | 1445 | // The "logical" on/off state of the port is the state set by the |
mjr | 99:8139b0c274f4 | 1446 | // client. The "physical" state is the state of the underlying port. |
mjr | 99:8139b0c274f4 | 1447 | // The relationships between logical and physical port state, and the |
mjr | 99:8139b0c274f4 | 1448 | // effects of updates by the client, are as follows: |
mjr | 99:8139b0c274f4 | 1449 | // |
mjr | 99:8139b0c274f4 | 1450 | // State | Logical | Physical | Client set on | Client set off |
mjr | 99:8139b0c274f4 | 1451 | // ----------------------------------------------------------- |
mjr | 99:8139b0c274f4 | 1452 | // 0 | Off | Off | phys on, -> 1 | no effect |
mjr | 99:8139b0c274f4 | 1453 | // 1 | On | On | no effect | -> 2 |
mjr | 99:8139b0c274f4 | 1454 | // 2 | Off | On | -> 1 | no effect |
mjr | 99:8139b0c274f4 | 1455 | // 3 | On | On | no effect | phys off, -> 0 |
mjr | 99:8139b0c274f4 | 1456 | // 4 | On | On | no effect | phys off, -> 0 |
mjr | 99:8139b0c274f4 | 1457 | // |
mjr | 99:8139b0c274f4 | 1458 | // The polling routine makes the following transitions when the current |
mjr | 99:8139b0c274f4 | 1459 | // time limit expires: |
mjr | 99:8139b0c274f4 | 1460 | // |
mjr | 99:8139b0c274f4 | 1461 | // 1: at end of minimum ON, -> 3 (or 4 if max == infinity) |
mjr | 99:8139b0c274f4 | 1462 | // 2: at end of minimum ON, port off, -> 0 |
mjr | 99:8139b0c274f4 | 1463 | // 3: at end of maximum ON, port off, -> 4 |
mjr | 98:4df3c0f7e707 | 1464 | // |
mjr | 98:4df3c0f7e707 | 1465 | uint8_t state; |
mjr | 98:4df3c0f7e707 | 1466 | |
mjr | 99:8139b0c274f4 | 1467 | // Configuration parameters byte. This encodes the minimum and maximum |
mjr | 99:8139b0c274f4 | 1468 | // ON times. |
mjr | 99:8139b0c274f4 | 1469 | uint8_t params; |
mjr | 98:4df3c0f7e707 | 1470 | |
mjr | 98:4df3c0f7e707 | 1471 | // Timer. This is a shared timer for all of the minimum ON time ports. |
mjr | 98:4df3c0f7e707 | 1472 | // When we transition from OFF to ON, we note the current time on this |
mjr | 98:4df3c0f7e707 | 1473 | // timer to establish the start of our minimum ON period. |
mjr | 98:4df3c0f7e707 | 1474 | static Timer timer; |
mjr | 98:4df3c0f7e707 | 1475 | |
mjr | 98:4df3c0f7e707 | 1476 | // translaton table from timing parameter in config to minimum ON time |
mjr | 98:4df3c0f7e707 | 1477 | static const uint32_t paramToTime_us[]; |
mjr | 98:4df3c0f7e707 | 1478 | |
mjr | 99:8139b0c274f4 | 1479 | // Figure the minimum ON time. The minimum ON time is given by the |
mjr | 99:8139b0c274f4 | 1480 | // low-order 4 bits of the parameters byte, which serves as an index |
mjr | 99:8139b0c274f4 | 1481 | // into our time table. |
mjr | 99:8139b0c274f4 | 1482 | inline uint32_t minOnTime_us() const { return paramToTime_us[params & 0x0F]; } |
mjr | 99:8139b0c274f4 | 1483 | |
mjr | 99:8139b0c274f4 | 1484 | // Figure the maximum ON time. The maximum time is the high 4 bits |
mjr | 99:8139b0c274f4 | 1485 | // of the parameters byte. This is an index into our time table, but |
mjr | 99:8139b0c274f4 | 1486 | // 0 has the special meaning "infinite". |
mjr | 99:8139b0c274f4 | 1487 | inline uint32_t maxOnTime_us() const { return paramToTime_us[((params >> 4) & 0x0F)]; } |
mjr | 98:4df3c0f7e707 | 1488 | |
mjr | 98:4df3c0f7e707 | 1489 | // Pending timer list. Whenever one of our ports transitions from OFF |
mjr | 98:4df3c0f7e707 | 1490 | // to ON, we add it to this list. We scan this list in our polling |
mjr | 98:4df3c0f7e707 | 1491 | // routine to find ports that have reached the ends of their initial |
mjr | 98:4df3c0f7e707 | 1492 | // ON intervals. |
mjr | 99:8139b0c274f4 | 1493 | static LwChimeLogicOut **pending; |
mjr | 98:4df3c0f7e707 | 1494 | static uint8_t nPending; |
mjr | 98:4df3c0f7e707 | 1495 | }; |
mjr | 98:4df3c0f7e707 | 1496 | |
mjr | 98:4df3c0f7e707 | 1497 | // Min Time Out statics |
mjr | 99:8139b0c274f4 | 1498 | Timer LwChimeLogicOut::timer; |
mjr | 99:8139b0c274f4 | 1499 | LwChimeLogicOut **LwChimeLogicOut::pending; |
mjr | 99:8139b0c274f4 | 1500 | uint8_t LwChimeLogicOut::nPending; |
mjr | 99:8139b0c274f4 | 1501 | const uint32_t LwChimeLogicOut::paramToTime_us[] = { |
mjr | 99:8139b0c274f4 | 1502 | 0, // for the max time, this means "infinite" |
mjr | 98:4df3c0f7e707 | 1503 | 1000, |
mjr | 98:4df3c0f7e707 | 1504 | 2000, |
mjr | 98:4df3c0f7e707 | 1505 | 5000, |
mjr | 98:4df3c0f7e707 | 1506 | 10000, |
mjr | 98:4df3c0f7e707 | 1507 | 20000, |
mjr | 98:4df3c0f7e707 | 1508 | 40000, |
mjr | 98:4df3c0f7e707 | 1509 | 80000, |
mjr | 98:4df3c0f7e707 | 1510 | 100000, |
mjr | 98:4df3c0f7e707 | 1511 | 200000, |
mjr | 98:4df3c0f7e707 | 1512 | 300000, |
mjr | 98:4df3c0f7e707 | 1513 | 400000, |
mjr | 98:4df3c0f7e707 | 1514 | 500000, |
mjr | 98:4df3c0f7e707 | 1515 | 600000, |
mjr | 98:4df3c0f7e707 | 1516 | 700000, |
mjr | 98:4df3c0f7e707 | 1517 | 800000 |
mjr | 98:4df3c0f7e707 | 1518 | }; |
mjr | 89:c43cd923401c | 1519 | |
mjr | 35:e959ffba78fd | 1520 | // |
mjr | 35:e959ffba78fd | 1521 | // The TLC5940 interface object. We'll set this up with the port |
mjr | 35:e959ffba78fd | 1522 | // assignments set in config.h. |
mjr | 33:d832bcab089e | 1523 | // |
mjr | 35:e959ffba78fd | 1524 | TLC5940 *tlc5940 = 0; |
mjr | 35:e959ffba78fd | 1525 | void init_tlc5940(Config &cfg) |
mjr | 35:e959ffba78fd | 1526 | { |
mjr | 35:e959ffba78fd | 1527 | if (cfg.tlc5940.nchips != 0) |
mjr | 35:e959ffba78fd | 1528 | { |
mjr | 53:9b2611964afc | 1529 | tlc5940 = new TLC5940( |
mjr | 53:9b2611964afc | 1530 | wirePinName(cfg.tlc5940.sclk), |
mjr | 53:9b2611964afc | 1531 | wirePinName(cfg.tlc5940.sin), |
mjr | 53:9b2611964afc | 1532 | wirePinName(cfg.tlc5940.gsclk), |
mjr | 53:9b2611964afc | 1533 | wirePinName(cfg.tlc5940.blank), |
mjr | 53:9b2611964afc | 1534 | wirePinName(cfg.tlc5940.xlat), |
mjr | 53:9b2611964afc | 1535 | cfg.tlc5940.nchips); |
mjr | 35:e959ffba78fd | 1536 | } |
mjr | 35:e959ffba78fd | 1537 | } |
mjr | 26:cb71c4af2912 | 1538 | |
mjr | 40:cc0d9814522b | 1539 | // Conversion table for 8-bit DOF level to 12-bit TLC5940 level |
mjr | 40:cc0d9814522b | 1540 | static const uint16_t dof_to_tlc[] = { |
mjr | 40:cc0d9814522b | 1541 | 0, 16, 32, 48, 64, 80, 96, 112, 128, 145, 161, 177, 193, 209, 225, 241, |
mjr | 40:cc0d9814522b | 1542 | 257, 273, 289, 305, 321, 337, 353, 369, 385, 401, 418, 434, 450, 466, 482, 498, |
mjr | 40:cc0d9814522b | 1543 | 514, 530, 546, 562, 578, 594, 610, 626, 642, 658, 674, 691, 707, 723, 739, 755, |
mjr | 40:cc0d9814522b | 1544 | 771, 787, 803, 819, 835, 851, 867, 883, 899, 915, 931, 947, 964, 980, 996, 1012, |
mjr | 40:cc0d9814522b | 1545 | 1028, 1044, 1060, 1076, 1092, 1108, 1124, 1140, 1156, 1172, 1188, 1204, 1220, 1237, 1253, 1269, |
mjr | 40:cc0d9814522b | 1546 | 1285, 1301, 1317, 1333, 1349, 1365, 1381, 1397, 1413, 1429, 1445, 1461, 1477, 1493, 1510, 1526, |
mjr | 40:cc0d9814522b | 1547 | 1542, 1558, 1574, 1590, 1606, 1622, 1638, 1654, 1670, 1686, 1702, 1718, 1734, 1750, 1766, 1783, |
mjr | 40:cc0d9814522b | 1548 | 1799, 1815, 1831, 1847, 1863, 1879, 1895, 1911, 1927, 1943, 1959, 1975, 1991, 2007, 2023, 2039, |
mjr | 40:cc0d9814522b | 1549 | 2056, 2072, 2088, 2104, 2120, 2136, 2152, 2168, 2184, 2200, 2216, 2232, 2248, 2264, 2280, 2296, |
mjr | 40:cc0d9814522b | 1550 | 2312, 2329, 2345, 2361, 2377, 2393, 2409, 2425, 2441, 2457, 2473, 2489, 2505, 2521, 2537, 2553, |
mjr | 40:cc0d9814522b | 1551 | 2569, 2585, 2602, 2618, 2634, 2650, 2666, 2682, 2698, 2714, 2730, 2746, 2762, 2778, 2794, 2810, |
mjr | 40:cc0d9814522b | 1552 | 2826, 2842, 2858, 2875, 2891, 2907, 2923, 2939, 2955, 2971, 2987, 3003, 3019, 3035, 3051, 3067, |
mjr | 40:cc0d9814522b | 1553 | 3083, 3099, 3115, 3131, 3148, 3164, 3180, 3196, 3212, 3228, 3244, 3260, 3276, 3292, 3308, 3324, |
mjr | 40:cc0d9814522b | 1554 | 3340, 3356, 3372, 3388, 3404, 3421, 3437, 3453, 3469, 3485, 3501, 3517, 3533, 3549, 3565, 3581, |
mjr | 40:cc0d9814522b | 1555 | 3597, 3613, 3629, 3645, 3661, 3677, 3694, 3710, 3726, 3742, 3758, 3774, 3790, 3806, 3822, 3838, |
mjr | 40:cc0d9814522b | 1556 | 3854, 3870, 3886, 3902, 3918, 3934, 3950, 3967, 3983, 3999, 4015, 4031, 4047, 4063, 4079, 4095 |
mjr | 40:cc0d9814522b | 1557 | }; |
mjr | 40:cc0d9814522b | 1558 | |
mjr | 40:cc0d9814522b | 1559 | // Conversion table for 8-bit DOF level to 12-bit TLC5940 level, with |
mjr | 40:cc0d9814522b | 1560 | // gamma correction. Note that the output layering scheme can handle |
mjr | 40:cc0d9814522b | 1561 | // this without a separate table, by first applying gamma to the DOF |
mjr | 40:cc0d9814522b | 1562 | // level to produce an 8-bit gamma-corrected value, then convert that |
mjr | 40:cc0d9814522b | 1563 | // to the 12-bit TLC5940 value. But we get better precision by doing |
mjr | 40:cc0d9814522b | 1564 | // the gamma correction in the 12-bit TLC5940 domain. We can only |
mjr | 40:cc0d9814522b | 1565 | // get the 12-bit domain by combining both steps into one layering |
mjr | 40:cc0d9814522b | 1566 | // object, though, since the intermediate values in the layering system |
mjr | 40:cc0d9814522b | 1567 | // are always 8 bits. |
mjr | 40:cc0d9814522b | 1568 | static const uint16_t dof_to_gamma_tlc[] = { |
mjr | 40:cc0d9814522b | 1569 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, |
mjr | 40:cc0d9814522b | 1570 | 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 8, 9, 10, 11, |
mjr | 40:cc0d9814522b | 1571 | 12, 13, 15, 16, 17, 18, 20, 21, 23, 25, 26, 28, 30, 32, 34, 36, |
mjr | 40:cc0d9814522b | 1572 | 38, 40, 43, 45, 48, 50, 53, 56, 59, 62, 65, 68, 71, 75, 78, 82, |
mjr | 40:cc0d9814522b | 1573 | 85, 89, 93, 97, 101, 105, 110, 114, 119, 123, 128, 133, 138, 143, 149, 154, |
mjr | 40:cc0d9814522b | 1574 | 159, 165, 171, 177, 183, 189, 195, 202, 208, 215, 222, 229, 236, 243, 250, 258, |
mjr | 40:cc0d9814522b | 1575 | 266, 273, 281, 290, 298, 306, 315, 324, 332, 341, 351, 360, 369, 379, 389, 399, |
mjr | 40:cc0d9814522b | 1576 | 409, 419, 430, 440, 451, 462, 473, 485, 496, 508, 520, 532, 544, 556, 569, 582, |
mjr | 40:cc0d9814522b | 1577 | 594, 608, 621, 634, 648, 662, 676, 690, 704, 719, 734, 749, 764, 779, 795, 811, |
mjr | 40:cc0d9814522b | 1578 | 827, 843, 859, 876, 893, 910, 927, 944, 962, 980, 998, 1016, 1034, 1053, 1072, 1091, |
mjr | 40:cc0d9814522b | 1579 | 1110, 1130, 1150, 1170, 1190, 1210, 1231, 1252, 1273, 1294, 1316, 1338, 1360, 1382, 1404, 1427, |
mjr | 40:cc0d9814522b | 1580 | 1450, 1473, 1497, 1520, 1544, 1568, 1593, 1617, 1642, 1667, 1693, 1718, 1744, 1770, 1797, 1823, |
mjr | 40:cc0d9814522b | 1581 | 1850, 1877, 1905, 1932, 1960, 1988, 2017, 2045, 2074, 2103, 2133, 2162, 2192, 2223, 2253, 2284, |
mjr | 40:cc0d9814522b | 1582 | 2315, 2346, 2378, 2410, 2442, 2474, 2507, 2540, 2573, 2606, 2640, 2674, 2708, 2743, 2778, 2813, |
mjr | 40:cc0d9814522b | 1583 | 2849, 2884, 2920, 2957, 2993, 3030, 3067, 3105, 3143, 3181, 3219, 3258, 3297, 3336, 3376, 3416, |
mjr | 40:cc0d9814522b | 1584 | 3456, 3496, 3537, 3578, 3619, 3661, 3703, 3745, 3788, 3831, 3874, 3918, 3962, 4006, 4050, 4095 |
mjr | 40:cc0d9814522b | 1585 | }; |
mjr | 40:cc0d9814522b | 1586 | |
mjr | 26:cb71c4af2912 | 1587 | // LwOut class for TLC5940 outputs. These are fully PWM capable. |
mjr | 26:cb71c4af2912 | 1588 | // The 'idx' value in the constructor is the output index in the |
mjr | 26:cb71c4af2912 | 1589 | // daisy-chained TLC5940 array. 0 is output #0 on the first chip, |
mjr | 26:cb71c4af2912 | 1590 | // 1 is #1 on the first chip, 15 is #15 on the first chip, 16 is |
mjr | 26:cb71c4af2912 | 1591 | // #0 on the second chip, 32 is #0 on the third chip, etc. |
mjr | 26:cb71c4af2912 | 1592 | class Lw5940Out: public LwOut |
mjr | 26:cb71c4af2912 | 1593 | { |
mjr | 26:cb71c4af2912 | 1594 | public: |
mjr | 60:f38da020aa13 | 1595 | Lw5940Out(uint8_t idx) : idx(idx) { prv = 0; } |
mjr | 40:cc0d9814522b | 1596 | virtual void set(uint8_t val) |
mjr | 26:cb71c4af2912 | 1597 | { |
mjr | 26:cb71c4af2912 | 1598 | if (val != prv) |
mjr | 40:cc0d9814522b | 1599 | tlc5940->set(idx, dof_to_tlc[prv = val]); |
mjr | 26:cb71c4af2912 | 1600 | } |
mjr | 60:f38da020aa13 | 1601 | uint8_t idx; |
mjr | 40:cc0d9814522b | 1602 | uint8_t prv; |
mjr | 26:cb71c4af2912 | 1603 | }; |
mjr | 26:cb71c4af2912 | 1604 | |
mjr | 40:cc0d9814522b | 1605 | // LwOut class for TLC5940 gamma-corrected outputs. |
mjr | 40:cc0d9814522b | 1606 | class Lw5940GammaOut: public LwOut |
mjr | 40:cc0d9814522b | 1607 | { |
mjr | 40:cc0d9814522b | 1608 | public: |
mjr | 60:f38da020aa13 | 1609 | Lw5940GammaOut(uint8_t idx) : idx(idx) { prv = 0; } |
mjr | 40:cc0d9814522b | 1610 | virtual void set(uint8_t val) |
mjr | 40:cc0d9814522b | 1611 | { |
mjr | 40:cc0d9814522b | 1612 | if (val != prv) |
mjr | 40:cc0d9814522b | 1613 | tlc5940->set(idx, dof_to_gamma_tlc[prv = val]); |
mjr | 40:cc0d9814522b | 1614 | } |
mjr | 60:f38da020aa13 | 1615 | uint8_t idx; |
mjr | 40:cc0d9814522b | 1616 | uint8_t prv; |
mjr | 40:cc0d9814522b | 1617 | }; |
mjr | 40:cc0d9814522b | 1618 | |
mjr | 87:8d35c74403af | 1619 | // |
mjr | 87:8d35c74403af | 1620 | // TLC59116 interface object |
mjr | 87:8d35c74403af | 1621 | // |
mjr | 87:8d35c74403af | 1622 | TLC59116 *tlc59116 = 0; |
mjr | 87:8d35c74403af | 1623 | void init_tlc59116(Config &cfg) |
mjr | 87:8d35c74403af | 1624 | { |
mjr | 87:8d35c74403af | 1625 | // Create the interface if any chips are enabled |
mjr | 87:8d35c74403af | 1626 | if (cfg.tlc59116.chipMask != 0) |
mjr | 87:8d35c74403af | 1627 | { |
mjr | 87:8d35c74403af | 1628 | // set up the interface |
mjr | 87:8d35c74403af | 1629 | tlc59116 = new TLC59116( |
mjr | 87:8d35c74403af | 1630 | wirePinName(cfg.tlc59116.sda), |
mjr | 87:8d35c74403af | 1631 | wirePinName(cfg.tlc59116.scl), |
mjr | 87:8d35c74403af | 1632 | wirePinName(cfg.tlc59116.reset)); |
mjr | 87:8d35c74403af | 1633 | |
mjr | 87:8d35c74403af | 1634 | // initialize the chips |
mjr | 87:8d35c74403af | 1635 | tlc59116->init(); |
mjr | 87:8d35c74403af | 1636 | } |
mjr | 87:8d35c74403af | 1637 | } |
mjr | 87:8d35c74403af | 1638 | |
mjr | 87:8d35c74403af | 1639 | // LwOut class for TLC59116 outputs. The 'addr' value in the constructor |
mjr | 87:8d35c74403af | 1640 | // is low 4 bits of the chip's I2C address; this is the part of the address |
mjr | 87:8d35c74403af | 1641 | // that's configurable per chip. 'port' is the output number on the chip |
mjr | 87:8d35c74403af | 1642 | // (0-15). |
mjr | 87:8d35c74403af | 1643 | // |
mjr | 87:8d35c74403af | 1644 | // Note that we don't need a separate gamma-corrected subclass for this |
mjr | 87:8d35c74403af | 1645 | // output type, since there's no loss of precision with the standard layered |
mjr | 87:8d35c74403af | 1646 | // gamma (it emits 8-bit values, and we take 8-bit inputs). |
mjr | 87:8d35c74403af | 1647 | class Lw59116Out: public LwOut |
mjr | 87:8d35c74403af | 1648 | { |
mjr | 87:8d35c74403af | 1649 | public: |
mjr | 87:8d35c74403af | 1650 | Lw59116Out(uint8_t addr, uint8_t port) : addr(addr), port(port) { prv = 0; } |
mjr | 87:8d35c74403af | 1651 | virtual void set(uint8_t val) |
mjr | 87:8d35c74403af | 1652 | { |
mjr | 87:8d35c74403af | 1653 | if (val != prv) |
mjr | 87:8d35c74403af | 1654 | tlc59116->set(addr, port, prv = val); |
mjr | 87:8d35c74403af | 1655 | } |
mjr | 87:8d35c74403af | 1656 | |
mjr | 87:8d35c74403af | 1657 | protected: |
mjr | 87:8d35c74403af | 1658 | uint8_t addr; |
mjr | 87:8d35c74403af | 1659 | uint8_t port; |
mjr | 87:8d35c74403af | 1660 | uint8_t prv; |
mjr | 87:8d35c74403af | 1661 | }; |
mjr | 87:8d35c74403af | 1662 | |
mjr | 87:8d35c74403af | 1663 | |
mjr | 87:8d35c74403af | 1664 | // |
mjr | 34:6b981a2afab7 | 1665 | // 74HC595 interface object. Set this up with the port assignments in |
mjr | 34:6b981a2afab7 | 1666 | // config.h. |
mjr | 87:8d35c74403af | 1667 | // |
mjr | 35:e959ffba78fd | 1668 | HC595 *hc595 = 0; |
mjr | 35:e959ffba78fd | 1669 | |
mjr | 35:e959ffba78fd | 1670 | // initialize the 74HC595 interface |
mjr | 35:e959ffba78fd | 1671 | void init_hc595(Config &cfg) |
mjr | 35:e959ffba78fd | 1672 | { |
mjr | 35:e959ffba78fd | 1673 | if (cfg.hc595.nchips != 0) |
mjr | 35:e959ffba78fd | 1674 | { |
mjr | 53:9b2611964afc | 1675 | hc595 = new HC595( |
mjr | 53:9b2611964afc | 1676 | wirePinName(cfg.hc595.nchips), |
mjr | 53:9b2611964afc | 1677 | wirePinName(cfg.hc595.sin), |
mjr | 53:9b2611964afc | 1678 | wirePinName(cfg.hc595.sclk), |
mjr | 53:9b2611964afc | 1679 | wirePinName(cfg.hc595.latch), |
mjr | 53:9b2611964afc | 1680 | wirePinName(cfg.hc595.ena)); |
mjr | 35:e959ffba78fd | 1681 | hc595->init(); |
mjr | 35:e959ffba78fd | 1682 | hc595->update(); |
mjr | 35:e959ffba78fd | 1683 | } |
mjr | 35:e959ffba78fd | 1684 | } |
mjr | 34:6b981a2afab7 | 1685 | |
mjr | 34:6b981a2afab7 | 1686 | // LwOut class for 74HC595 outputs. These are simple digial outs. |
mjr | 34:6b981a2afab7 | 1687 | // The 'idx' value in the constructor is the output index in the |
mjr | 34:6b981a2afab7 | 1688 | // daisy-chained 74HC595 array. 0 is output #0 on the first chip, |
mjr | 34:6b981a2afab7 | 1689 | // 1 is #1 on the first chip, 7 is #7 on the first chip, 8 is |
mjr | 34:6b981a2afab7 | 1690 | // #0 on the second chip, etc. |
mjr | 34:6b981a2afab7 | 1691 | class Lw595Out: public LwOut |
mjr | 33:d832bcab089e | 1692 | { |
mjr | 33:d832bcab089e | 1693 | public: |
mjr | 60:f38da020aa13 | 1694 | Lw595Out(uint8_t idx) : idx(idx) { prv = 0; } |
mjr | 40:cc0d9814522b | 1695 | virtual void set(uint8_t val) |
mjr | 34:6b981a2afab7 | 1696 | { |
mjr | 34:6b981a2afab7 | 1697 | if (val != prv) |
mjr | 40:cc0d9814522b | 1698 | hc595->set(idx, (prv = val) == 0 ? 0 : 1); |
mjr | 34:6b981a2afab7 | 1699 | } |
mjr | 60:f38da020aa13 | 1700 | uint8_t idx; |
mjr | 40:cc0d9814522b | 1701 | uint8_t prv; |
mjr | 33:d832bcab089e | 1702 | }; |
mjr | 33:d832bcab089e | 1703 | |
mjr | 26:cb71c4af2912 | 1704 | |
mjr | 40:cc0d9814522b | 1705 | |
mjr | 64:ef7ca92dff36 | 1706 | // Conversion table - 8-bit DOF output level to PWM duty cycle, |
mjr | 64:ef7ca92dff36 | 1707 | // normalized to 0.0 to 1.0 scale. |
mjr | 74:822a92bc11d2 | 1708 | static const float dof_to_pwm[] = { |
mjr | 64:ef7ca92dff36 | 1709 | 0.000000f, 0.003922f, 0.007843f, 0.011765f, 0.015686f, 0.019608f, 0.023529f, 0.027451f, |
mjr | 64:ef7ca92dff36 | 1710 | 0.031373f, 0.035294f, 0.039216f, 0.043137f, 0.047059f, 0.050980f, 0.054902f, 0.058824f, |
mjr | 64:ef7ca92dff36 | 1711 | 0.062745f, 0.066667f, 0.070588f, 0.074510f, 0.078431f, 0.082353f, 0.086275f, 0.090196f, |
mjr | 64:ef7ca92dff36 | 1712 | 0.094118f, 0.098039f, 0.101961f, 0.105882f, 0.109804f, 0.113725f, 0.117647f, 0.121569f, |
mjr | 64:ef7ca92dff36 | 1713 | 0.125490f, 0.129412f, 0.133333f, 0.137255f, 0.141176f, 0.145098f, 0.149020f, 0.152941f, |
mjr | 64:ef7ca92dff36 | 1714 | 0.156863f, 0.160784f, 0.164706f, 0.168627f, 0.172549f, 0.176471f, 0.180392f, 0.184314f, |
mjr | 64:ef7ca92dff36 | 1715 | 0.188235f, 0.192157f, 0.196078f, 0.200000f, 0.203922f, 0.207843f, 0.211765f, 0.215686f, |
mjr | 64:ef7ca92dff36 | 1716 | 0.219608f, 0.223529f, 0.227451f, 0.231373f, 0.235294f, 0.239216f, 0.243137f, 0.247059f, |
mjr | 64:ef7ca92dff36 | 1717 | 0.250980f, 0.254902f, 0.258824f, 0.262745f, 0.266667f, 0.270588f, 0.274510f, 0.278431f, |
mjr | 64:ef7ca92dff36 | 1718 | 0.282353f, 0.286275f, 0.290196f, 0.294118f, 0.298039f, 0.301961f, 0.305882f, 0.309804f, |
mjr | 64:ef7ca92dff36 | 1719 | 0.313725f, 0.317647f, 0.321569f, 0.325490f, 0.329412f, 0.333333f, 0.337255f, 0.341176f, |
mjr | 64:ef7ca92dff36 | 1720 | 0.345098f, 0.349020f, 0.352941f, 0.356863f, 0.360784f, 0.364706f, 0.368627f, 0.372549f, |
mjr | 64:ef7ca92dff36 | 1721 | 0.376471f, 0.380392f, 0.384314f, 0.388235f, 0.392157f, 0.396078f, 0.400000f, 0.403922f, |
mjr | 64:ef7ca92dff36 | 1722 | 0.407843f, 0.411765f, 0.415686f, 0.419608f, 0.423529f, 0.427451f, 0.431373f, 0.435294f, |
mjr | 64:ef7ca92dff36 | 1723 | 0.439216f, 0.443137f, 0.447059f, 0.450980f, 0.454902f, 0.458824f, 0.462745f, 0.466667f, |
mjr | 64:ef7ca92dff36 | 1724 | 0.470588f, 0.474510f, 0.478431f, 0.482353f, 0.486275f, 0.490196f, 0.494118f, 0.498039f, |
mjr | 64:ef7ca92dff36 | 1725 | 0.501961f, 0.505882f, 0.509804f, 0.513725f, 0.517647f, 0.521569f, 0.525490f, 0.529412f, |
mjr | 64:ef7ca92dff36 | 1726 | 0.533333f, 0.537255f, 0.541176f, 0.545098f, 0.549020f, 0.552941f, 0.556863f, 0.560784f, |
mjr | 64:ef7ca92dff36 | 1727 | 0.564706f, 0.568627f, 0.572549f, 0.576471f, 0.580392f, 0.584314f, 0.588235f, 0.592157f, |
mjr | 64:ef7ca92dff36 | 1728 | 0.596078f, 0.600000f, 0.603922f, 0.607843f, 0.611765f, 0.615686f, 0.619608f, 0.623529f, |
mjr | 64:ef7ca92dff36 | 1729 | 0.627451f, 0.631373f, 0.635294f, 0.639216f, 0.643137f, 0.647059f, 0.650980f, 0.654902f, |
mjr | 64:ef7ca92dff36 | 1730 | 0.658824f, 0.662745f, 0.666667f, 0.670588f, 0.674510f, 0.678431f, 0.682353f, 0.686275f, |
mjr | 64:ef7ca92dff36 | 1731 | 0.690196f, 0.694118f, 0.698039f, 0.701961f, 0.705882f, 0.709804f, 0.713725f, 0.717647f, |
mjr | 64:ef7ca92dff36 | 1732 | 0.721569f, 0.725490f, 0.729412f, 0.733333f, 0.737255f, 0.741176f, 0.745098f, 0.749020f, |
mjr | 64:ef7ca92dff36 | 1733 | 0.752941f, 0.756863f, 0.760784f, 0.764706f, 0.768627f, 0.772549f, 0.776471f, 0.780392f, |
mjr | 64:ef7ca92dff36 | 1734 | 0.784314f, 0.788235f, 0.792157f, 0.796078f, 0.800000f, 0.803922f, 0.807843f, 0.811765f, |
mjr | 64:ef7ca92dff36 | 1735 | 0.815686f, 0.819608f, 0.823529f, 0.827451f, 0.831373f, 0.835294f, 0.839216f, 0.843137f, |
mjr | 64:ef7ca92dff36 | 1736 | 0.847059f, 0.850980f, 0.854902f, 0.858824f, 0.862745f, 0.866667f, 0.870588f, 0.874510f, |
mjr | 64:ef7ca92dff36 | 1737 | 0.878431f, 0.882353f, 0.886275f, 0.890196f, 0.894118f, 0.898039f, 0.901961f, 0.905882f, |
mjr | 64:ef7ca92dff36 | 1738 | 0.909804f, 0.913725f, 0.917647f, 0.921569f, 0.925490f, 0.929412f, 0.933333f, 0.937255f, |
mjr | 64:ef7ca92dff36 | 1739 | 0.941176f, 0.945098f, 0.949020f, 0.952941f, 0.956863f, 0.960784f, 0.964706f, 0.968627f, |
mjr | 64:ef7ca92dff36 | 1740 | 0.972549f, 0.976471f, 0.980392f, 0.984314f, 0.988235f, 0.992157f, 0.996078f, 1.000000f |
mjr | 40:cc0d9814522b | 1741 | }; |
mjr | 26:cb71c4af2912 | 1742 | |
mjr | 64:ef7ca92dff36 | 1743 | |
mjr | 92:f264fbaa1be5 | 1744 | // Conversion table for 8-bit DOF level to pulse width, with gamma correction |
mjr | 92:f264fbaa1be5 | 1745 | // pre-calculated. The values are normalized duty cycles from 0.0 to 1.0. |
mjr | 92:f264fbaa1be5 | 1746 | // Note that we could use the layered gamma output on top of the regular |
mjr | 92:f264fbaa1be5 | 1747 | // LwPwmOut class for this instead of a separate table, but we get much better |
mjr | 92:f264fbaa1be5 | 1748 | // precision with a dedicated table, because we apply gamma correction to the |
mjr | 92:f264fbaa1be5 | 1749 | // actual duty cycle values (as 'float') rather than the 8-bit DOF values. |
mjr | 64:ef7ca92dff36 | 1750 | static const float dof_to_gamma_pwm[] = { |
mjr | 64:ef7ca92dff36 | 1751 | 0.000000f, 0.000000f, 0.000001f, 0.000004f, 0.000009f, 0.000017f, 0.000028f, 0.000042f, |
mjr | 64:ef7ca92dff36 | 1752 | 0.000062f, 0.000086f, 0.000115f, 0.000151f, 0.000192f, 0.000240f, 0.000296f, 0.000359f, |
mjr | 64:ef7ca92dff36 | 1753 | 0.000430f, 0.000509f, 0.000598f, 0.000695f, 0.000803f, 0.000920f, 0.001048f, 0.001187f, |
mjr | 64:ef7ca92dff36 | 1754 | 0.001337f, 0.001499f, 0.001673f, 0.001860f, 0.002059f, 0.002272f, 0.002498f, 0.002738f, |
mjr | 64:ef7ca92dff36 | 1755 | 0.002993f, 0.003262f, 0.003547f, 0.003847f, 0.004162f, 0.004494f, 0.004843f, 0.005208f, |
mjr | 64:ef7ca92dff36 | 1756 | 0.005591f, 0.005991f, 0.006409f, 0.006845f, 0.007301f, 0.007775f, 0.008268f, 0.008781f, |
mjr | 64:ef7ca92dff36 | 1757 | 0.009315f, 0.009868f, 0.010442f, 0.011038f, 0.011655f, 0.012293f, 0.012954f, 0.013637f, |
mjr | 64:ef7ca92dff36 | 1758 | 0.014342f, 0.015071f, 0.015823f, 0.016599f, 0.017398f, 0.018223f, 0.019071f, 0.019945f, |
mjr | 64:ef7ca92dff36 | 1759 | 0.020844f, 0.021769f, 0.022720f, 0.023697f, 0.024701f, 0.025731f, 0.026789f, 0.027875f, |
mjr | 64:ef7ca92dff36 | 1760 | 0.028988f, 0.030129f, 0.031299f, 0.032498f, 0.033726f, 0.034983f, 0.036270f, 0.037587f, |
mjr | 64:ef7ca92dff36 | 1761 | 0.038935f, 0.040313f, 0.041722f, 0.043162f, 0.044634f, 0.046138f, 0.047674f, 0.049243f, |
mjr | 64:ef7ca92dff36 | 1762 | 0.050844f, 0.052478f, 0.054146f, 0.055847f, 0.057583f, 0.059353f, 0.061157f, 0.062996f, |
mjr | 64:ef7ca92dff36 | 1763 | 0.064870f, 0.066780f, 0.068726f, 0.070708f, 0.072726f, 0.074780f, 0.076872f, 0.079001f, |
mjr | 64:ef7ca92dff36 | 1764 | 0.081167f, 0.083371f, 0.085614f, 0.087895f, 0.090214f, 0.092572f, 0.094970f, 0.097407f, |
mjr | 64:ef7ca92dff36 | 1765 | 0.099884f, 0.102402f, 0.104959f, 0.107558f, 0.110197f, 0.112878f, 0.115600f, 0.118364f, |
mjr | 64:ef7ca92dff36 | 1766 | 0.121170f, 0.124019f, 0.126910f, 0.129844f, 0.132821f, 0.135842f, 0.138907f, 0.142016f, |
mjr | 64:ef7ca92dff36 | 1767 | 0.145170f, 0.148367f, 0.151610f, 0.154898f, 0.158232f, 0.161611f, 0.165037f, 0.168509f, |
mjr | 64:ef7ca92dff36 | 1768 | 0.172027f, 0.175592f, 0.179205f, 0.182864f, 0.186572f, 0.190327f, 0.194131f, 0.197983f, |
mjr | 64:ef7ca92dff36 | 1769 | 0.201884f, 0.205834f, 0.209834f, 0.213883f, 0.217982f, 0.222131f, 0.226330f, 0.230581f, |
mjr | 64:ef7ca92dff36 | 1770 | 0.234882f, 0.239234f, 0.243638f, 0.248094f, 0.252602f, 0.257162f, 0.261774f, 0.266440f, |
mjr | 64:ef7ca92dff36 | 1771 | 0.271159f, 0.275931f, 0.280756f, 0.285636f, 0.290570f, 0.295558f, 0.300601f, 0.305699f, |
mjr | 64:ef7ca92dff36 | 1772 | 0.310852f, 0.316061f, 0.321325f, 0.326645f, 0.332022f, 0.337456f, 0.342946f, 0.348493f, |
mjr | 64:ef7ca92dff36 | 1773 | 0.354098f, 0.359760f, 0.365480f, 0.371258f, 0.377095f, 0.382990f, 0.388944f, 0.394958f, |
mjr | 64:ef7ca92dff36 | 1774 | 0.401030f, 0.407163f, 0.413356f, 0.419608f, 0.425921f, 0.432295f, 0.438730f, 0.445226f, |
mjr | 64:ef7ca92dff36 | 1775 | 0.451784f, 0.458404f, 0.465085f, 0.471829f, 0.478635f, 0.485504f, 0.492436f, 0.499432f, |
mjr | 64:ef7ca92dff36 | 1776 | 0.506491f, 0.513614f, 0.520800f, 0.528052f, 0.535367f, 0.542748f, 0.550194f, 0.557705f, |
mjr | 64:ef7ca92dff36 | 1777 | 0.565282f, 0.572924f, 0.580633f, 0.588408f, 0.596249f, 0.604158f, 0.612133f, 0.620176f, |
mjr | 64:ef7ca92dff36 | 1778 | 0.628287f, 0.636465f, 0.644712f, 0.653027f, 0.661410f, 0.669863f, 0.678384f, 0.686975f, |
mjr | 64:ef7ca92dff36 | 1779 | 0.695636f, 0.704366f, 0.713167f, 0.722038f, 0.730979f, 0.739992f, 0.749075f, 0.758230f, |
mjr | 64:ef7ca92dff36 | 1780 | 0.767457f, 0.776755f, 0.786126f, 0.795568f, 0.805084f, 0.814672f, 0.824334f, 0.834068f, |
mjr | 64:ef7ca92dff36 | 1781 | 0.843877f, 0.853759f, 0.863715f, 0.873746f, 0.883851f, 0.894031f, 0.904286f, 0.914616f, |
mjr | 64:ef7ca92dff36 | 1782 | 0.925022f, 0.935504f, 0.946062f, 0.956696f, 0.967407f, 0.978194f, 0.989058f, 1.000000f |
mjr | 64:ef7ca92dff36 | 1783 | }; |
mjr | 64:ef7ca92dff36 | 1784 | |
mjr | 77:0b96f6867312 | 1785 | // Polled-update PWM output list |
mjr | 74:822a92bc11d2 | 1786 | // |
mjr | 77:0b96f6867312 | 1787 | // This is a workaround for a KL25Z hardware bug/limitation. The bug (more |
mjr | 77:0b96f6867312 | 1788 | // about this below) is that we can't write to a PWM output "value" register |
mjr | 77:0b96f6867312 | 1789 | // more than once per PWM cycle; if we do, outputs after the first are lost. |
mjr | 77:0b96f6867312 | 1790 | // The value register controls the duty cycle, so it's what you have to write |
mjr | 77:0b96f6867312 | 1791 | // if you want to update the brightness of an output. |
mjr | 74:822a92bc11d2 | 1792 | // |
mjr | 92:f264fbaa1be5 | 1793 | // The symptom of the problem, if it's not worked around somehow, is that |
mjr | 92:f264fbaa1be5 | 1794 | // an output will get "stuck" due to a missed write. This is especially |
mjr | 92:f264fbaa1be5 | 1795 | // noticeable during a series of updates such as a fade. If the last |
mjr | 92:f264fbaa1be5 | 1796 | // couple of updates in a fade are lost, the output will get stuck at some |
mjr | 92:f264fbaa1be5 | 1797 | // value above or below the desired final value. The stuck setting will |
mjr | 92:f264fbaa1be5 | 1798 | // persist until the output is deliberately changed again later. |
mjr | 92:f264fbaa1be5 | 1799 | // |
mjr | 92:f264fbaa1be5 | 1800 | // Our solution: Simply repeat all PWM updates periodically. This way, any |
mjr | 92:f264fbaa1be5 | 1801 | // lost write will *eventually* take hold on one of the repeats. Repeats of |
mjr | 92:f264fbaa1be5 | 1802 | // the same value won't change anything and thus won't be noticeable. We do |
mjr | 92:f264fbaa1be5 | 1803 | // these periodic updates during the main loop, which makes them very low |
mjr | 92:f264fbaa1be5 | 1804 | // overhead (there's no interrupt overhead; we just do them when convenient |
mjr | 92:f264fbaa1be5 | 1805 | // in the main loop), and also makes them very frequent. The frequency |
mjr | 92:f264fbaa1be5 | 1806 | // is crucial because it ensures that updates will never be lost for long |
mjr | 92:f264fbaa1be5 | 1807 | // enough to become noticeable. |
mjr | 92:f264fbaa1be5 | 1808 | // |
mjr | 92:f264fbaa1be5 | 1809 | // The mbed library has its own, different solution to this bug, but the |
mjr | 92:f264fbaa1be5 | 1810 | // mbed solution isn't really a solution at all because it creates a separate |
mjr | 100:1ff35c07217c | 1811 | // problem of its own. The mbed approach is to reset the TPM "count" register |
mjr | 92:f264fbaa1be5 | 1812 | // on every value register write. The count reset truncates the current |
mjr | 92:f264fbaa1be5 | 1813 | // PWM cycle, which bypasses the hardware problem. Remember, the hardware |
mjr | 92:f264fbaa1be5 | 1814 | // problem is that you can only write once per cycle; the mbed "solution" gets |
mjr | 92:f264fbaa1be5 | 1815 | // around that by making sure the cycle ends immediately after the write. |
mjr | 92:f264fbaa1be5 | 1816 | // The problem with this approach is that the truncated cycle causes visible |
mjr | 92:f264fbaa1be5 | 1817 | // flicker if the output is connected to an LED. This is particularly |
mjr | 92:f264fbaa1be5 | 1818 | // noticeable during fades, when we're updating the value register repeatedly |
mjr | 92:f264fbaa1be5 | 1819 | // and rapidly: an attempt to fade from fully on to fully off causes rapid |
mjr | 92:f264fbaa1be5 | 1820 | // fluttering and flashing rather than a smooth brightness fade. That's why |
mjr | 92:f264fbaa1be5 | 1821 | // I had to come up with something different - the mbed solution just trades |
mjr | 92:f264fbaa1be5 | 1822 | // one annoying bug for another that's just as bad. |
mjr | 92:f264fbaa1be5 | 1823 | // |
mjr | 92:f264fbaa1be5 | 1824 | // The hardware bug, by the way, is a case of good intentions gone bad. |
mjr | 92:f264fbaa1be5 | 1825 | // The whole point of the staging register is to make things easier for |
mjr | 92:f264fbaa1be5 | 1826 | // us software writers. In most PWM hardware, software has to coordinate |
mjr | 92:f264fbaa1be5 | 1827 | // with the PWM duty cycle when updating registers to avoid a glitch that |
mjr | 92:f264fbaa1be5 | 1828 | // you'd get by scribbling to the duty cycle register mid-cycle. The |
mjr | 92:f264fbaa1be5 | 1829 | // staging register solves this by letting the software write an update at |
mjr | 92:f264fbaa1be5 | 1830 | // any time, knowing that the hardware will apply the update at exactly the |
mjr | 92:f264fbaa1be5 | 1831 | // end of the cycle, ensuring glitch-free updates. It's a great design, |
mjr | 92:f264fbaa1be5 | 1832 | // except that it doesn't quite work. The problem is that they implemented |
mjr | 92:f264fbaa1be5 | 1833 | // this clever staging register as a one-element FIFO that refuses any more |
mjr | 92:f264fbaa1be5 | 1834 | // writes when full. That is, writing a value to the FIFO fills it; once |
mjr | 92:f264fbaa1be5 | 1835 | // full, it ignores writes until it gets emptied out. How's it emptied out? |
mjr | 92:f264fbaa1be5 | 1836 | // By the hardware moving the staged value to the real register. Sadly, they |
mjr | 92:f264fbaa1be5 | 1837 | // didn't provide any way for the software to clear the register, and no way |
mjr | 92:f264fbaa1be5 | 1838 | // to even tell that it's full. So we don't have glitches on write, but we're |
mjr | 92:f264fbaa1be5 | 1839 | // back to the original problem that the software has to be aware of the PWM |
mjr | 92:f264fbaa1be5 | 1840 | // cycle timing, because the only way for the software to know that a write |
mjr | 92:f264fbaa1be5 | 1841 | // actually worked is to know that it's been at least one PWM cycle since the |
mjr | 92:f264fbaa1be5 | 1842 | // last write. That largely defeats the whole purpose of the staging register, |
mjr | 92:f264fbaa1be5 | 1843 | // since the whole point was to free software writers of these timing |
mjr | 92:f264fbaa1be5 | 1844 | // considerations. It's still an improvement over no staging register at |
mjr | 92:f264fbaa1be5 | 1845 | // all, since we at least don't have to worry about glitches, but it leaves |
mjr | 92:f264fbaa1be5 | 1846 | // us with this somewhat similar hassle. |
mjr | 74:822a92bc11d2 | 1847 | // |
mjr | 77:0b96f6867312 | 1848 | // So here we have our list of PWM outputs that need to be polled for updates. |
mjr | 77:0b96f6867312 | 1849 | // The KL25Z hardware only has 10 PWM channels, so we only need a fixed set |
mjr | 77:0b96f6867312 | 1850 | // of polled items. |
mjr | 74:822a92bc11d2 | 1851 | static int numPolledPwm; |
mjr | 74:822a92bc11d2 | 1852 | static class LwPwmOut *polledPwm[10]; |
mjr | 74:822a92bc11d2 | 1853 | |
mjr | 74:822a92bc11d2 | 1854 | // LwOut class for a PWM-capable GPIO port. |
mjr | 6:cc35eb643e8f | 1855 | class LwPwmOut: public LwOut |
mjr | 6:cc35eb643e8f | 1856 | { |
mjr | 6:cc35eb643e8f | 1857 | public: |
mjr | 43:7a6364d82a41 | 1858 | LwPwmOut(PinName pin, uint8_t initVal) : p(pin) |
mjr | 43:7a6364d82a41 | 1859 | { |
mjr | 77:0b96f6867312 | 1860 | // add myself to the list of polled outputs for periodic updates |
mjr | 77:0b96f6867312 | 1861 | if (numPolledPwm < countof(polledPwm)) |
mjr | 74:822a92bc11d2 | 1862 | polledPwm[numPolledPwm++] = this; |
mjr | 93:177832c29041 | 1863 | |
mjr | 94:0476b3e2b996 | 1864 | // IMPORTANT: Do not set the PWM period (frequency) here explicitly. |
mjr | 94:0476b3e2b996 | 1865 | // We instead want to accept the current setting for the TPM unit |
mjr | 94:0476b3e2b996 | 1866 | // we're assigned to. The KL25Z hardware can only set the period at |
mjr | 94:0476b3e2b996 | 1867 | // the TPM unit level, not per channel, so if we changed the frequency |
mjr | 94:0476b3e2b996 | 1868 | // here, we'd change it for everything attached to our TPM unit. LW |
mjr | 94:0476b3e2b996 | 1869 | // outputs don't care about frequency other than that it's fast enough |
mjr | 94:0476b3e2b996 | 1870 | // that attached LEDs won't flicker. Some other PWM users (IR remote, |
mjr | 94:0476b3e2b996 | 1871 | // TLC5940) DO care about exact frequencies, because they use the PWM |
mjr | 94:0476b3e2b996 | 1872 | // as a signal generator rather than merely for brightness control. |
mjr | 94:0476b3e2b996 | 1873 | // If we changed the frequency here, we could clobber one of those |
mjr | 94:0476b3e2b996 | 1874 | // carefully chosen frequencies and break the other subsystem. So |
mjr | 94:0476b3e2b996 | 1875 | // we need to be the "free variable" here and accept whatever setting |
mjr | 94:0476b3e2b996 | 1876 | // is currently on our assigned unit. To minimize flicker, the main() |
mjr | 94:0476b3e2b996 | 1877 | // entrypoint sets a default PWM rate of 1kHz on all channels. All |
mjr | 94:0476b3e2b996 | 1878 | // of the other subsystems that might set specific frequencies will |
mjr | 94:0476b3e2b996 | 1879 | // set much high frequencies, so that should only be good for us. |
mjr | 94:0476b3e2b996 | 1880 | |
mjr | 94:0476b3e2b996 | 1881 | // set the initial brightness value |
mjr | 77:0b96f6867312 | 1882 | set(initVal); |
mjr | 43:7a6364d82a41 | 1883 | } |
mjr | 74:822a92bc11d2 | 1884 | |
mjr | 40:cc0d9814522b | 1885 | virtual void set(uint8_t val) |
mjr | 74:822a92bc11d2 | 1886 | { |
mjr | 77:0b96f6867312 | 1887 | // save the new value |
mjr | 74:822a92bc11d2 | 1888 | this->val = val; |
mjr | 77:0b96f6867312 | 1889 | |
mjr | 77:0b96f6867312 | 1890 | // commit it to the hardware |
mjr | 77:0b96f6867312 | 1891 | commit(); |
mjr | 13:72dda449c3c0 | 1892 | } |
mjr | 74:822a92bc11d2 | 1893 | |
mjr | 74:822a92bc11d2 | 1894 | // handle periodic update polling |
mjr | 74:822a92bc11d2 | 1895 | void poll() |
mjr | 74:822a92bc11d2 | 1896 | { |
mjr | 77:0b96f6867312 | 1897 | commit(); |
mjr | 74:822a92bc11d2 | 1898 | } |
mjr | 74:822a92bc11d2 | 1899 | |
mjr | 74:822a92bc11d2 | 1900 | protected: |
mjr | 77:0b96f6867312 | 1901 | virtual void commit() |
mjr | 74:822a92bc11d2 | 1902 | { |
mjr | 74:822a92bc11d2 | 1903 | // write the current value to the PWM controller if it's changed |
mjr | 77:0b96f6867312 | 1904 | p.glitchFreeWrite(dof_to_pwm[val]); |
mjr | 74:822a92bc11d2 | 1905 | } |
mjr | 74:822a92bc11d2 | 1906 | |
mjr | 77:0b96f6867312 | 1907 | NewPwmOut p; |
mjr | 77:0b96f6867312 | 1908 | uint8_t val; |
mjr | 6:cc35eb643e8f | 1909 | }; |
mjr | 26:cb71c4af2912 | 1910 | |
mjr | 74:822a92bc11d2 | 1911 | // Gamma corrected PWM GPIO output. This works exactly like the regular |
mjr | 74:822a92bc11d2 | 1912 | // PWM output, but translates DOF values through the gamma-corrected |
mjr | 74:822a92bc11d2 | 1913 | // table instead of the regular linear table. |
mjr | 64:ef7ca92dff36 | 1914 | class LwPwmGammaOut: public LwPwmOut |
mjr | 64:ef7ca92dff36 | 1915 | { |
mjr | 64:ef7ca92dff36 | 1916 | public: |
mjr | 64:ef7ca92dff36 | 1917 | LwPwmGammaOut(PinName pin, uint8_t initVal) |
mjr | 64:ef7ca92dff36 | 1918 | : LwPwmOut(pin, initVal) |
mjr | 64:ef7ca92dff36 | 1919 | { |
mjr | 64:ef7ca92dff36 | 1920 | } |
mjr | 74:822a92bc11d2 | 1921 | |
mjr | 74:822a92bc11d2 | 1922 | protected: |
mjr | 77:0b96f6867312 | 1923 | virtual void commit() |
mjr | 64:ef7ca92dff36 | 1924 | { |
mjr | 74:822a92bc11d2 | 1925 | // write the current value to the PWM controller if it's changed |
mjr | 77:0b96f6867312 | 1926 | p.glitchFreeWrite(dof_to_gamma_pwm[val]); |
mjr | 64:ef7ca92dff36 | 1927 | } |
mjr | 64:ef7ca92dff36 | 1928 | }; |
mjr | 64:ef7ca92dff36 | 1929 | |
mjr | 74:822a92bc11d2 | 1930 | // poll the PWM outputs |
mjr | 74:822a92bc11d2 | 1931 | Timer polledPwmTimer; |
mjr | 76:7f5912b6340e | 1932 | uint64_t polledPwmTotalTime, polledPwmRunCount; |
mjr | 74:822a92bc11d2 | 1933 | void pollPwmUpdates() |
mjr | 74:822a92bc11d2 | 1934 | { |
mjr | 94:0476b3e2b996 | 1935 | // If it's been long enough since the last update, do another update. |
mjr | 94:0476b3e2b996 | 1936 | // Note that the time limit is fairly arbitrary: it has to be at least |
mjr | 94:0476b3e2b996 | 1937 | // 1.5X the PWM period, so that we can be sure that at least one PWM |
mjr | 94:0476b3e2b996 | 1938 | // period has elapsed since the last update, but there's no hard upper |
mjr | 94:0476b3e2b996 | 1939 | // bound. Instead, it only has to be short enough that fades don't |
mjr | 94:0476b3e2b996 | 1940 | // become noticeably chunky. The competing interest is that we don't |
mjr | 94:0476b3e2b996 | 1941 | // want to do this more often than necessary to provide incremental |
mjr | 94:0476b3e2b996 | 1942 | // benefit, because the polling adds overhead to the main loop and |
mjr | 94:0476b3e2b996 | 1943 | // takes time away from other tasks we could be performing. The |
mjr | 94:0476b3e2b996 | 1944 | // shortest time with practical benefit is probably around 50-60Hz, |
mjr | 94:0476b3e2b996 | 1945 | // since that gives us "video rate" granularity in fades. Anything |
mjr | 94:0476b3e2b996 | 1946 | // faster wouldn't probably make fades look any smoother to a human |
mjr | 94:0476b3e2b996 | 1947 | // viewer. |
mjr | 94:0476b3e2b996 | 1948 | if (polledPwmTimer.read_us() >= 15000) |
mjr | 74:822a92bc11d2 | 1949 | { |
mjr | 74:822a92bc11d2 | 1950 | // time the run for statistics collection |
mjr | 74:822a92bc11d2 | 1951 | IF_DIAG( |
mjr | 74:822a92bc11d2 | 1952 | Timer t; |
mjr | 74:822a92bc11d2 | 1953 | t.start(); |
mjr | 74:822a92bc11d2 | 1954 | ) |
mjr | 74:822a92bc11d2 | 1955 | |
mjr | 74:822a92bc11d2 | 1956 | // poll each output |
mjr | 74:822a92bc11d2 | 1957 | for (int i = numPolledPwm ; i > 0 ; ) |
mjr | 74:822a92bc11d2 | 1958 | polledPwm[--i]->poll(); |
mjr | 74:822a92bc11d2 | 1959 | |
mjr | 74:822a92bc11d2 | 1960 | // reset the timer for the next cycle |
mjr | 74:822a92bc11d2 | 1961 | polledPwmTimer.reset(); |
mjr | 74:822a92bc11d2 | 1962 | |
mjr | 74:822a92bc11d2 | 1963 | // collect statistics |
mjr | 74:822a92bc11d2 | 1964 | IF_DIAG( |
mjr | 76:7f5912b6340e | 1965 | polledPwmTotalTime += t.read_us(); |
mjr | 74:822a92bc11d2 | 1966 | polledPwmRunCount += 1; |
mjr | 74:822a92bc11d2 | 1967 | ) |
mjr | 74:822a92bc11d2 | 1968 | } |
mjr | 74:822a92bc11d2 | 1969 | } |
mjr | 64:ef7ca92dff36 | 1970 | |
mjr | 26:cb71c4af2912 | 1971 | // LwOut class for a Digital-Only (Non-PWM) GPIO port |
mjr | 6:cc35eb643e8f | 1972 | class LwDigOut: public LwOut |
mjr | 6:cc35eb643e8f | 1973 | { |
mjr | 6:cc35eb643e8f | 1974 | public: |
mjr | 43:7a6364d82a41 | 1975 | LwDigOut(PinName pin, uint8_t initVal) : p(pin, initVal ? 1 : 0) { prv = initVal; } |
mjr | 40:cc0d9814522b | 1976 | virtual void set(uint8_t val) |
mjr | 13:72dda449c3c0 | 1977 | { |
mjr | 13:72dda449c3c0 | 1978 | if (val != prv) |
mjr | 40:cc0d9814522b | 1979 | p.write((prv = val) == 0 ? 0 : 1); |
mjr | 13:72dda449c3c0 | 1980 | } |
mjr | 6:cc35eb643e8f | 1981 | DigitalOut p; |
mjr | 40:cc0d9814522b | 1982 | uint8_t prv; |
mjr | 6:cc35eb643e8f | 1983 | }; |
mjr | 26:cb71c4af2912 | 1984 | |
mjr | 29:582472d0bc57 | 1985 | // Array of output physical pin assignments. This array is indexed |
mjr | 29:582472d0bc57 | 1986 | // by LedWiz logical port number - lwPin[n] is the maping for LedWiz |
mjr | 35:e959ffba78fd | 1987 | // port n (0-based). |
mjr | 35:e959ffba78fd | 1988 | // |
mjr | 35:e959ffba78fd | 1989 | // Each pin is handled by an interface object for the physical output |
mjr | 35:e959ffba78fd | 1990 | // type for the port, as set in the configuration. The interface |
mjr | 35:e959ffba78fd | 1991 | // objects handle the specifics of addressing the different hardware |
mjr | 35:e959ffba78fd | 1992 | // types (GPIO PWM ports, GPIO digital ports, TLC5940 ports, and |
mjr | 35:e959ffba78fd | 1993 | // 74HC595 ports). |
mjr | 33:d832bcab089e | 1994 | static int numOutputs; |
mjr | 33:d832bcab089e | 1995 | static LwOut **lwPin; |
mjr | 33:d832bcab089e | 1996 | |
mjr | 38:091e511ce8a0 | 1997 | // create a single output pin |
mjr | 53:9b2611964afc | 1998 | LwOut *createLwPin(int portno, LedWizPortCfg &pc, Config &cfg) |
mjr | 38:091e511ce8a0 | 1999 | { |
mjr | 38:091e511ce8a0 | 2000 | // get this item's values |
mjr | 38:091e511ce8a0 | 2001 | int typ = pc.typ; |
mjr | 38:091e511ce8a0 | 2002 | int pin = pc.pin; |
mjr | 38:091e511ce8a0 | 2003 | int flags = pc.flags; |
mjr | 40:cc0d9814522b | 2004 | int noisy = flags & PortFlagNoisemaker; |
mjr | 38:091e511ce8a0 | 2005 | int activeLow = flags & PortFlagActiveLow; |
mjr | 40:cc0d9814522b | 2006 | int gamma = flags & PortFlagGamma; |
mjr | 89:c43cd923401c | 2007 | int flipperLogic = flags & PortFlagFlipperLogic; |
mjr | 99:8139b0c274f4 | 2008 | int chimeLogic = flags & PortFlagChimeLogic; |
mjr | 89:c43cd923401c | 2009 | |
mjr | 89:c43cd923401c | 2010 | // cancel gamma on flipper logic ports |
mjr | 89:c43cd923401c | 2011 | if (flipperLogic) |
mjr | 89:c43cd923401c | 2012 | gamma = false; |
mjr | 38:091e511ce8a0 | 2013 | |
mjr | 38:091e511ce8a0 | 2014 | // create the pin interface object according to the port type |
mjr | 38:091e511ce8a0 | 2015 | LwOut *lwp; |
mjr | 38:091e511ce8a0 | 2016 | switch (typ) |
mjr | 38:091e511ce8a0 | 2017 | { |
mjr | 38:091e511ce8a0 | 2018 | case PortTypeGPIOPWM: |
mjr | 48:058ace2aed1d | 2019 | // PWM GPIO port - assign if we have a valid pin |
mjr | 48:058ace2aed1d | 2020 | if (pin != 0) |
mjr | 64:ef7ca92dff36 | 2021 | { |
mjr | 64:ef7ca92dff36 | 2022 | // If gamma correction is to be used, and we're not inverting the output, |
mjr | 64:ef7ca92dff36 | 2023 | // use the combined Pwmout + Gamma output class; otherwise use the plain |
mjr | 64:ef7ca92dff36 | 2024 | // PwmOut class. We can't use the combined class for inverted outputs |
mjr | 64:ef7ca92dff36 | 2025 | // because we have to apply gamma correction before the inversion. |
mjr | 64:ef7ca92dff36 | 2026 | if (gamma && !activeLow) |
mjr | 64:ef7ca92dff36 | 2027 | { |
mjr | 64:ef7ca92dff36 | 2028 | // use the gamma-corrected PwmOut type |
mjr | 64:ef7ca92dff36 | 2029 | lwp = new LwPwmGammaOut(wirePinName(pin), 0); |
mjr | 64:ef7ca92dff36 | 2030 | |
mjr | 64:ef7ca92dff36 | 2031 | // don't apply further gamma correction to this output |
mjr | 64:ef7ca92dff36 | 2032 | gamma = false; |
mjr | 64:ef7ca92dff36 | 2033 | } |
mjr | 64:ef7ca92dff36 | 2034 | else |
mjr | 64:ef7ca92dff36 | 2035 | { |
mjr | 64:ef7ca92dff36 | 2036 | // no gamma correction - use the standard PwmOut class |
mjr | 64:ef7ca92dff36 | 2037 | lwp = new LwPwmOut(wirePinName(pin), activeLow ? 255 : 0); |
mjr | 64:ef7ca92dff36 | 2038 | } |
mjr | 64:ef7ca92dff36 | 2039 | } |
mjr | 48:058ace2aed1d | 2040 | else |
mjr | 48:058ace2aed1d | 2041 | lwp = new LwVirtualOut(); |
mjr | 38:091e511ce8a0 | 2042 | break; |
mjr | 38:091e511ce8a0 | 2043 | |
mjr | 38:091e511ce8a0 | 2044 | case PortTypeGPIODig: |
mjr | 38:091e511ce8a0 | 2045 | // Digital GPIO port |
mjr | 48:058ace2aed1d | 2046 | if (pin != 0) |
mjr | 48:058ace2aed1d | 2047 | lwp = new LwDigOut(wirePinName(pin), activeLow ? 255 : 0); |
mjr | 48:058ace2aed1d | 2048 | else |
mjr | 48:058ace2aed1d | 2049 | lwp = new LwVirtualOut(); |
mjr | 38:091e511ce8a0 | 2050 | break; |
mjr | 38:091e511ce8a0 | 2051 | |
mjr | 38:091e511ce8a0 | 2052 | case PortTypeTLC5940: |
mjr | 38:091e511ce8a0 | 2053 | // TLC5940 port (if we don't have a TLC controller object, or it's not a valid |
mjr | 38:091e511ce8a0 | 2054 | // output port number on the chips we have, create a virtual port) |
mjr | 38:091e511ce8a0 | 2055 | if (tlc5940 != 0 && pin < cfg.tlc5940.nchips*16) |
mjr | 40:cc0d9814522b | 2056 | { |
mjr | 40:cc0d9814522b | 2057 | // If gamma correction is to be used, and we're not inverting the output, |
mjr | 40:cc0d9814522b | 2058 | // use the combined TLC4950 + Gamma output class. Otherwise use the plain |
mjr | 40:cc0d9814522b | 2059 | // TLC5940 output. We skip the combined class if the output is inverted |
mjr | 40:cc0d9814522b | 2060 | // because we need to apply gamma BEFORE the inversion to get the right |
mjr | 40:cc0d9814522b | 2061 | // results, but the combined class would apply it after because of the |
mjr | 40:cc0d9814522b | 2062 | // layering scheme - the combined class is a physical device output class, |
mjr | 40:cc0d9814522b | 2063 | // and a physical device output class is necessarily at the bottom of |
mjr | 40:cc0d9814522b | 2064 | // the stack. We don't have a combined inverted+gamma+TLC class, because |
mjr | 40:cc0d9814522b | 2065 | // inversion isn't recommended for TLC5940 chips in the first place, so |
mjr | 40:cc0d9814522b | 2066 | // it's not worth the extra memory footprint to have a dedicated table |
mjr | 40:cc0d9814522b | 2067 | // for this unlikely case. |
mjr | 40:cc0d9814522b | 2068 | if (gamma && !activeLow) |
mjr | 40:cc0d9814522b | 2069 | { |
mjr | 40:cc0d9814522b | 2070 | // use the gamma-corrected 5940 output mapper |
mjr | 40:cc0d9814522b | 2071 | lwp = new Lw5940GammaOut(pin); |
mjr | 40:cc0d9814522b | 2072 | |
mjr | 40:cc0d9814522b | 2073 | // DON'T apply further gamma correction to this output |
mjr | 40:cc0d9814522b | 2074 | gamma = false; |
mjr | 40:cc0d9814522b | 2075 | } |
mjr | 40:cc0d9814522b | 2076 | else |
mjr | 40:cc0d9814522b | 2077 | { |
mjr | 40:cc0d9814522b | 2078 | // no gamma - use the plain (linear) 5940 output class |
mjr | 40:cc0d9814522b | 2079 | lwp = new Lw5940Out(pin); |
mjr | 40:cc0d9814522b | 2080 | } |
mjr | 40:cc0d9814522b | 2081 | } |
mjr | 38:091e511ce8a0 | 2082 | else |
mjr | 40:cc0d9814522b | 2083 | { |
mjr | 40:cc0d9814522b | 2084 | // no TLC5940 chips, or invalid port number - use a virtual out |
mjr | 38:091e511ce8a0 | 2085 | lwp = new LwVirtualOut(); |
mjr | 40:cc0d9814522b | 2086 | } |
mjr | 38:091e511ce8a0 | 2087 | break; |
mjr | 38:091e511ce8a0 | 2088 | |
mjr | 38:091e511ce8a0 | 2089 | case PortType74HC595: |
mjr | 87:8d35c74403af | 2090 | // 74HC595 port (if we don't have an HC595 controller object, or it's not |
mjr | 87:8d35c74403af | 2091 | // a valid output number, create a virtual port) |
mjr | 38:091e511ce8a0 | 2092 | if (hc595 != 0 && pin < cfg.hc595.nchips*8) |
mjr | 38:091e511ce8a0 | 2093 | lwp = new Lw595Out(pin); |
mjr | 38:091e511ce8a0 | 2094 | else |
mjr | 38:091e511ce8a0 | 2095 | lwp = new LwVirtualOut(); |
mjr | 38:091e511ce8a0 | 2096 | break; |
mjr | 87:8d35c74403af | 2097 | |
mjr | 87:8d35c74403af | 2098 | case PortTypeTLC59116: |
mjr | 87:8d35c74403af | 2099 | // TLC59116 port. The pin number in the config encodes the chip address |
mjr | 87:8d35c74403af | 2100 | // in the high 4 bits and the output number on the chip in the low 4 bits. |
mjr | 87:8d35c74403af | 2101 | // There's no gamma-corrected version of this output handler, so we don't |
mjr | 87:8d35c74403af | 2102 | // need to worry about that here; just use the layered gamma as needed. |
mjr | 87:8d35c74403af | 2103 | if (tlc59116 != 0) |
mjr | 87:8d35c74403af | 2104 | lwp = new Lw59116Out((pin >> 4) & 0x0F, pin & 0x0F); |
mjr | 87:8d35c74403af | 2105 | break; |
mjr | 38:091e511ce8a0 | 2106 | |
mjr | 38:091e511ce8a0 | 2107 | case PortTypeVirtual: |
mjr | 43:7a6364d82a41 | 2108 | case PortTypeDisabled: |
mjr | 38:091e511ce8a0 | 2109 | default: |
mjr | 38:091e511ce8a0 | 2110 | // virtual or unknown |
mjr | 38:091e511ce8a0 | 2111 | lwp = new LwVirtualOut(); |
mjr | 38:091e511ce8a0 | 2112 | break; |
mjr | 38:091e511ce8a0 | 2113 | } |
mjr | 38:091e511ce8a0 | 2114 | |
mjr | 40:cc0d9814522b | 2115 | // If it's Active Low, layer on an inverter. Note that an inverter |
mjr | 40:cc0d9814522b | 2116 | // needs to be the bottom-most layer, since all of the other filters |
mjr | 40:cc0d9814522b | 2117 | // assume that they're working with normal (non-inverted) values. |
mjr | 38:091e511ce8a0 | 2118 | if (activeLow) |
mjr | 38:091e511ce8a0 | 2119 | lwp = new LwInvertedOut(lwp); |
mjr | 40:cc0d9814522b | 2120 | |
mjr | 89:c43cd923401c | 2121 | // Layer on Flipper Logic if desired |
mjr | 89:c43cd923401c | 2122 | if (flipperLogic) |
mjr | 89:c43cd923401c | 2123 | lwp = new LwFlipperLogicOut(lwp, pc.flipperLogic); |
mjr | 89:c43cd923401c | 2124 | |
mjr | 99:8139b0c274f4 | 2125 | // Layer on Chime Logic if desired. Note that Chime Logic and |
mjr | 99:8139b0c274f4 | 2126 | // Flipper Logic are mutually exclusive, and Flipper Logic takes |
mjr | 99:8139b0c274f4 | 2127 | // precedence, so ignore the Chime Logic bit if both are set. |
mjr | 99:8139b0c274f4 | 2128 | if (chimeLogic && !flipperLogic) |
mjr | 99:8139b0c274f4 | 2129 | lwp = new LwChimeLogicOut(lwp, pc.flipperLogic); |
mjr | 98:4df3c0f7e707 | 2130 | |
mjr | 89:c43cd923401c | 2131 | // If it's a noisemaker, layer on a night mode switch |
mjr | 40:cc0d9814522b | 2132 | if (noisy) |
mjr | 40:cc0d9814522b | 2133 | lwp = new LwNoisyOut(lwp); |
mjr | 40:cc0d9814522b | 2134 | |
mjr | 40:cc0d9814522b | 2135 | // If it's gamma-corrected, layer on a gamma corrector |
mjr | 40:cc0d9814522b | 2136 | if (gamma) |
mjr | 40:cc0d9814522b | 2137 | lwp = new LwGammaOut(lwp); |
mjr | 53:9b2611964afc | 2138 | |
mjr | 53:9b2611964afc | 2139 | // If this is the ZB Launch Ball port, layer a monitor object. Note |
mjr | 64:ef7ca92dff36 | 2140 | // that the nominal port numbering in the config starts at 1, but we're |
mjr | 53:9b2611964afc | 2141 | // using an array index, so test against portno+1. |
mjr | 53:9b2611964afc | 2142 | if (portno + 1 == cfg.plunger.zbLaunchBall.port) |
mjr | 53:9b2611964afc | 2143 | lwp = new LwZbLaunchOut(lwp); |
mjr | 53:9b2611964afc | 2144 | |
mjr | 53:9b2611964afc | 2145 | // If this is the Night Mode indicator port, layer a night mode object. |
mjr | 53:9b2611964afc | 2146 | if (portno + 1 == cfg.nightMode.port) |
mjr | 53:9b2611964afc | 2147 | lwp = new LwNightModeIndicatorOut(lwp); |
mjr | 38:091e511ce8a0 | 2148 | |
mjr | 38:091e511ce8a0 | 2149 | // turn it off initially |
mjr | 38:091e511ce8a0 | 2150 | lwp->set(0); |
mjr | 38:091e511ce8a0 | 2151 | |
mjr | 38:091e511ce8a0 | 2152 | // return the pin |
mjr | 38:091e511ce8a0 | 2153 | return lwp; |
mjr | 38:091e511ce8a0 | 2154 | } |
mjr | 38:091e511ce8a0 | 2155 | |
mjr | 6:cc35eb643e8f | 2156 | // initialize the output pin array |
mjr | 35:e959ffba78fd | 2157 | void initLwOut(Config &cfg) |
mjr | 6:cc35eb643e8f | 2158 | { |
mjr | 99:8139b0c274f4 | 2159 | // Initialize the Flipper Logic and Chime Logic outputs |
mjr | 89:c43cd923401c | 2160 | LwFlipperLogicOut::classInit(cfg); |
mjr | 99:8139b0c274f4 | 2161 | LwChimeLogicOut::classInit(cfg); |
mjr | 89:c43cd923401c | 2162 | |
mjr | 35:e959ffba78fd | 2163 | // Count the outputs. The first disabled output determines the |
mjr | 35:e959ffba78fd | 2164 | // total number of ports. |
mjr | 35:e959ffba78fd | 2165 | numOutputs = MAX_OUT_PORTS; |
mjr | 33:d832bcab089e | 2166 | int i; |
mjr | 35:e959ffba78fd | 2167 | for (i = 0 ; i < MAX_OUT_PORTS ; ++i) |
mjr | 6:cc35eb643e8f | 2168 | { |
mjr | 35:e959ffba78fd | 2169 | if (cfg.outPort[i].typ == PortTypeDisabled) |
mjr | 34:6b981a2afab7 | 2170 | { |
mjr | 35:e959ffba78fd | 2171 | numOutputs = i; |
mjr | 34:6b981a2afab7 | 2172 | break; |
mjr | 34:6b981a2afab7 | 2173 | } |
mjr | 33:d832bcab089e | 2174 | } |
mjr | 33:d832bcab089e | 2175 | |
mjr | 73:4e8ce0b18915 | 2176 | // allocate the pin array |
mjr | 73:4e8ce0b18915 | 2177 | lwPin = new LwOut*[numOutputs]; |
mjr | 35:e959ffba78fd | 2178 | |
mjr | 73:4e8ce0b18915 | 2179 | // Allocate the current brightness array |
mjr | 73:4e8ce0b18915 | 2180 | outLevel = new uint8_t[numOutputs]; |
mjr | 33:d832bcab089e | 2181 | |
mjr | 114:c2410d2cfaf1 | 2182 | // initialize all brightness levels to 0 (off) |
mjr | 114:c2410d2cfaf1 | 2183 | memset(outLevel, 0, numOutputs); |
mjr | 114:c2410d2cfaf1 | 2184 | |
mjr | 73:4e8ce0b18915 | 2185 | // allocate the LedWiz output state arrays |
mjr | 73:4e8ce0b18915 | 2186 | wizOn = new uint8_t[numOutputs]; |
mjr | 73:4e8ce0b18915 | 2187 | wizVal = new uint8_t[numOutputs]; |
mjr | 73:4e8ce0b18915 | 2188 | |
mjr | 73:4e8ce0b18915 | 2189 | // initialize all LedWiz outputs to off and brightness 48 |
mjr | 73:4e8ce0b18915 | 2190 | memset(wizOn, 0, numOutputs); |
mjr | 73:4e8ce0b18915 | 2191 | memset(wizVal, 48, numOutputs); |
mjr | 73:4e8ce0b18915 | 2192 | |
mjr | 73:4e8ce0b18915 | 2193 | // set all LedWiz virtual unit flash speeds to 2 |
mjr | 73:4e8ce0b18915 | 2194 | for (i = 0 ; i < countof(wizSpeed) ; ++i) |
mjr | 73:4e8ce0b18915 | 2195 | wizSpeed[i] = 2; |
mjr | 33:d832bcab089e | 2196 | |
mjr | 35:e959ffba78fd | 2197 | // create the pin interface object for each port |
mjr | 35:e959ffba78fd | 2198 | for (i = 0 ; i < numOutputs ; ++i) |
mjr | 53:9b2611964afc | 2199 | lwPin[i] = createLwPin(i, cfg.outPort[i], cfg); |
mjr | 6:cc35eb643e8f | 2200 | } |
mjr | 6:cc35eb643e8f | 2201 | |
mjr | 76:7f5912b6340e | 2202 | // Translate an LedWiz brightness level (0..49) to a DOF brightness |
mjr | 76:7f5912b6340e | 2203 | // level (0..255). Note that brightness level 49 isn't actually valid, |
mjr | 76:7f5912b6340e | 2204 | // according to the LedWiz API documentation, but many clients use it |
mjr | 76:7f5912b6340e | 2205 | // anyway, and the real LedWiz accepts it and seems to treat it as |
mjr | 76:7f5912b6340e | 2206 | // equivalent to 48. |
mjr | 40:cc0d9814522b | 2207 | static const uint8_t lw_to_dof[] = { |
mjr | 40:cc0d9814522b | 2208 | 0, 5, 11, 16, 21, 27, 32, 37, |
mjr | 40:cc0d9814522b | 2209 | 43, 48, 53, 58, 64, 69, 74, 80, |
mjr | 40:cc0d9814522b | 2210 | 85, 90, 96, 101, 106, 112, 117, 122, |
mjr | 40:cc0d9814522b | 2211 | 128, 133, 138, 143, 149, 154, 159, 165, |
mjr | 40:cc0d9814522b | 2212 | 170, 175, 181, 186, 191, 197, 202, 207, |
mjr | 40:cc0d9814522b | 2213 | 213, 218, 223, 228, 234, 239, 244, 250, |
mjr | 40:cc0d9814522b | 2214 | 255, 255 |
mjr | 40:cc0d9814522b | 2215 | }; |
mjr | 40:cc0d9814522b | 2216 | |
mjr | 76:7f5912b6340e | 2217 | // Translate a DOF brightness level (0..255) to an LedWiz brightness |
mjr | 76:7f5912b6340e | 2218 | // level (1..48) |
mjr | 76:7f5912b6340e | 2219 | static const uint8_t dof_to_lw[] = { |
mjr | 76:7f5912b6340e | 2220 | 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, |
mjr | 76:7f5912b6340e | 2221 | 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, |
mjr | 76:7f5912b6340e | 2222 | 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, |
mjr | 76:7f5912b6340e | 2223 | 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 12, 12, |
mjr | 76:7f5912b6340e | 2224 | 12, 12, 12, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, |
mjr | 76:7f5912b6340e | 2225 | 15, 15, 15, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, |
mjr | 76:7f5912b6340e | 2226 | 18, 18, 18, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 21, 21, 21, |
mjr | 76:7f5912b6340e | 2227 | 21, 21, 21, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 24, 24, 24, |
mjr | 76:7f5912b6340e | 2228 | 24, 24, 24, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 27, 27, 27, |
mjr | 76:7f5912b6340e | 2229 | 27, 27, 27, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 30, 30, 30, |
mjr | 76:7f5912b6340e | 2230 | 30, 30, 30, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 33, 33, |
mjr | 76:7f5912b6340e | 2231 | 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 36, 36, |
mjr | 76:7f5912b6340e | 2232 | 36, 36, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 39, 39, 39, |
mjr | 76:7f5912b6340e | 2233 | 39, 39, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 42, 42, |
mjr | 76:7f5912b6340e | 2234 | 42, 42, 43, 43, 43, 43, 43, 43, 44, 44, 44, 44, 44, 45, 45, 45, |
mjr | 76:7f5912b6340e | 2235 | 45, 45, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 48, 48, 48 |
mjr | 76:7f5912b6340e | 2236 | }; |
mjr | 76:7f5912b6340e | 2237 | |
mjr | 74:822a92bc11d2 | 2238 | // LedWiz flash cycle tables. For efficiency, we use a lookup table |
mjr | 74:822a92bc11d2 | 2239 | // rather than calculating these on the fly. The flash cycles are |
mjr | 74:822a92bc11d2 | 2240 | // generated by the following formulas, where 'c' is the current |
mjr | 74:822a92bc11d2 | 2241 | // cycle counter, from 0 to 255: |
mjr | 74:822a92bc11d2 | 2242 | // |
mjr | 74:822a92bc11d2 | 2243 | // mode 129 = sawtooth = (c < 128 ? c*2 + 1 : (255-c)*2) |
mjr | 74:822a92bc11d2 | 2244 | // mode 130 = flash on/off = (c < 128 ? 255 : 0) |
mjr | 74:822a92bc11d2 | 2245 | // mode 131 = on/ramp down = (c < 128 ? 255 : (255-c)*2) |
mjr | 74:822a92bc11d2 | 2246 | // mode 132 = ramp up/on = (c < 128 ? c*2 : 255) |
mjr | 74:822a92bc11d2 | 2247 | // |
mjr | 74:822a92bc11d2 | 2248 | // To look up the current output value for a given mode and a given |
mjr | 74:822a92bc11d2 | 2249 | // cycle counter 'c', index the table with ((mode-129)*256)+c. |
mjr | 74:822a92bc11d2 | 2250 | static const uint8_t wizFlashLookup[] = { |
mjr | 74:822a92bc11d2 | 2251 | // mode 129 = sawtooth = (c < 128 ? c*2 + 1 : (255-c)*2) |
mjr | 74:822a92bc11d2 | 2252 | 0x01, 0x03, 0x05, 0x07, 0x09, 0x0b, 0x0d, 0x0f, 0x11, 0x13, 0x15, 0x17, 0x19, 0x1b, 0x1d, 0x1f, |
mjr | 74:822a92bc11d2 | 2253 | 0x21, 0x23, 0x25, 0x27, 0x29, 0x2b, 0x2d, 0x2f, 0x31, 0x33, 0x35, 0x37, 0x39, 0x3b, 0x3d, 0x3f, |
mjr | 74:822a92bc11d2 | 2254 | 0x41, 0x43, 0x45, 0x47, 0x49, 0x4b, 0x4d, 0x4f, 0x51, 0x53, 0x55, 0x57, 0x59, 0x5b, 0x5d, 0x5f, |
mjr | 74:822a92bc11d2 | 2255 | 0x61, 0x63, 0x65, 0x67, 0x69, 0x6b, 0x6d, 0x6f, 0x71, 0x73, 0x75, 0x77, 0x79, 0x7b, 0x7d, 0x7f, |
mjr | 74:822a92bc11d2 | 2256 | 0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d, 0x8f, 0x91, 0x93, 0x95, 0x97, 0x99, 0x9b, 0x9d, 0x9f, |
mjr | 74:822a92bc11d2 | 2257 | 0xa1, 0xa3, 0xa5, 0xa7, 0xa9, 0xab, 0xad, 0xaf, 0xb1, 0xb3, 0xb5, 0xb7, 0xb9, 0xbb, 0xbd, 0xbf, |
mjr | 74:822a92bc11d2 | 2258 | 0xc1, 0xc3, 0xc5, 0xc7, 0xc9, 0xcb, 0xcd, 0xcf, 0xd1, 0xd3, 0xd5, 0xd7, 0xd9, 0xdb, 0xdd, 0xdf, |
mjr | 74:822a92bc11d2 | 2259 | 0xe1, 0xe3, 0xe5, 0xe7, 0xe9, 0xeb, 0xed, 0xef, 0xf1, 0xf3, 0xf5, 0xf7, 0xf9, 0xfb, 0xfd, 0xff, |
mjr | 74:822a92bc11d2 | 2260 | 0xfe, 0xfc, 0xfa, 0xf8, 0xf6, 0xf4, 0xf2, 0xf0, 0xee, 0xec, 0xea, 0xe8, 0xe6, 0xe4, 0xe2, 0xe0, |
mjr | 74:822a92bc11d2 | 2261 | 0xde, 0xdc, 0xda, 0xd8, 0xd6, 0xd4, 0xd2, 0xd0, 0xce, 0xcc, 0xca, 0xc8, 0xc6, 0xc4, 0xc2, 0xc0, |
mjr | 74:822a92bc11d2 | 2262 | 0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, 0xb2, 0xb0, 0xae, 0xac, 0xaa, 0xa8, 0xa6, 0xa4, 0xa2, 0xa0, |
mjr | 74:822a92bc11d2 | 2263 | 0x9e, 0x9c, 0x9a, 0x98, 0x96, 0x94, 0x92, 0x90, 0x8e, 0x8c, 0x8a, 0x88, 0x86, 0x84, 0x82, 0x80, |
mjr | 74:822a92bc11d2 | 2264 | 0x7e, 0x7c, 0x7a, 0x78, 0x76, 0x74, 0x72, 0x70, 0x6e, 0x6c, 0x6a, 0x68, 0x66, 0x64, 0x62, 0x60, |
mjr | 74:822a92bc11d2 | 2265 | 0x5e, 0x5c, 0x5a, 0x58, 0x56, 0x54, 0x52, 0x50, 0x4e, 0x4c, 0x4a, 0x48, 0x46, 0x44, 0x42, 0x40, |
mjr | 74:822a92bc11d2 | 2266 | 0x3e, 0x3c, 0x3a, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2e, 0x2c, 0x2a, 0x28, 0x26, 0x24, 0x22, 0x20, |
mjr | 74:822a92bc11d2 | 2267 | 0x1e, 0x1c, 0x1a, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x04, 0x02, 0x00, |
mjr | 74:822a92bc11d2 | 2268 | |
mjr | 74:822a92bc11d2 | 2269 | // mode 130 = flash on/off = (c < 128 ? 255 : 0) |
mjr | 74:822a92bc11d2 | 2270 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2271 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2272 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2273 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2274 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2275 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2276 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2277 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2278 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2279 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2280 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2281 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2282 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2283 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2284 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2285 | 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
mjr | 74:822a92bc11d2 | 2286 | |
mjr | 74:822a92bc11d2 | 2287 | // mode 131 = on/ramp down = c < 128 ? 255 : (255 - c)*2 |
mjr | 74:822a92bc11d2 | 2288 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2289 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2290 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2291 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2292 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2293 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2294 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2295 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2296 | 0xfe, 0xfc, 0xfa, 0xf8, 0xf6, 0xf4, 0xf2, 0xf0, 0xee, 0xec, 0xea, 0xe8, 0xe6, 0xe4, 0xe2, 0xe0, |
mjr | 74:822a92bc11d2 | 2297 | 0xde, 0xdc, 0xda, 0xd8, 0xd6, 0xd4, 0xd2, 0xd0, 0xce, 0xcc, 0xca, 0xc8, 0xc6, 0xc4, 0xc2, 0xc0, |
mjr | 74:822a92bc11d2 | 2298 | 0xbe, 0xbc, 0xba, 0xb8, 0xb6, 0xb4, 0xb2, 0xb0, 0xae, 0xac, 0xaa, 0xa8, 0xa6, 0xa4, 0xa2, 0xa0, |
mjr | 74:822a92bc11d2 | 2299 | 0x9e, 0x9c, 0x9a, 0x98, 0x96, 0x94, 0x92, 0x90, 0x8e, 0x8c, 0x8a, 0x88, 0x86, 0x84, 0x82, 0x80, |
mjr | 74:822a92bc11d2 | 2300 | 0x7e, 0x7c, 0x7a, 0x78, 0x76, 0x74, 0x72, 0x70, 0x6e, 0x6c, 0x6a, 0x68, 0x66, 0x64, 0x62, 0x60, |
mjr | 74:822a92bc11d2 | 2301 | 0x5e, 0x5c, 0x5a, 0x58, 0x56, 0x54, 0x52, 0x50, 0x4e, 0x4c, 0x4a, 0x48, 0x46, 0x44, 0x42, 0x40, |
mjr | 74:822a92bc11d2 | 2302 | 0x3e, 0x3c, 0x3a, 0x38, 0x36, 0x34, 0x32, 0x30, 0x2e, 0x2c, 0x2a, 0x28, 0x26, 0x24, 0x22, 0x20, |
mjr | 74:822a92bc11d2 | 2303 | 0x1e, 0x1c, 0x1a, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x04, 0x02, 0x00, |
mjr | 74:822a92bc11d2 | 2304 | |
mjr | 74:822a92bc11d2 | 2305 | // mode 132 = ramp up/on = c < 128 ? c*2 : 255 |
mjr | 74:822a92bc11d2 | 2306 | 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, |
mjr | 74:822a92bc11d2 | 2307 | 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, |
mjr | 74:822a92bc11d2 | 2308 | 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, |
mjr | 74:822a92bc11d2 | 2309 | 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, |
mjr | 74:822a92bc11d2 | 2310 | 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, |
mjr | 74:822a92bc11d2 | 2311 | 0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, |
mjr | 74:822a92bc11d2 | 2312 | 0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde, |
mjr | 74:822a92bc11d2 | 2313 | 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, |
mjr | 74:822a92bc11d2 | 2314 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2315 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2316 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2317 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2318 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2319 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2320 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
mjr | 74:822a92bc11d2 | 2321 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff |
mjr | 74:822a92bc11d2 | 2322 | }; |
mjr | 74:822a92bc11d2 | 2323 | |
mjr | 74:822a92bc11d2 | 2324 | // LedWiz flash cycle timer. This runs continuously. On each update, |
mjr | 74:822a92bc11d2 | 2325 | // we use this to figure out where we are on the cycle for each bank. |
mjr | 74:822a92bc11d2 | 2326 | Timer wizCycleTimer; |
mjr | 74:822a92bc11d2 | 2327 | |
mjr | 76:7f5912b6340e | 2328 | // timing statistics for wizPulse() |
mjr | 76:7f5912b6340e | 2329 | uint64_t wizPulseTotalTime, wizPulseRunCount; |
mjr | 76:7f5912b6340e | 2330 | |
mjr | 76:7f5912b6340e | 2331 | // LedWiz flash timer pulse. The main loop calls this on each cycle |
mjr | 76:7f5912b6340e | 2332 | // to update outputs using LedWiz flash modes. We do one bank of 32 |
mjr | 76:7f5912b6340e | 2333 | // outputs on each cycle. |
mjr | 29:582472d0bc57 | 2334 | static void wizPulse() |
mjr | 29:582472d0bc57 | 2335 | { |
mjr | 76:7f5912b6340e | 2336 | // current bank |
mjr | 76:7f5912b6340e | 2337 | static int wizPulseBank = 0; |
mjr | 76:7f5912b6340e | 2338 | |
mjr | 76:7f5912b6340e | 2339 | // start a timer for statistics collection |
mjr | 76:7f5912b6340e | 2340 | IF_DIAG( |
mjr | 76:7f5912b6340e | 2341 | Timer t; |
mjr | 76:7f5912b6340e | 2342 | t.start(); |
mjr | 76:7f5912b6340e | 2343 | ) |
mjr | 76:7f5912b6340e | 2344 | |
mjr | 76:7f5912b6340e | 2345 | // Update the current bank's cycle counter: figure the current |
mjr | 76:7f5912b6340e | 2346 | // phase of the LedWiz pulse cycle for this bank. |
mjr | 76:7f5912b6340e | 2347 | // |
mjr | 76:7f5912b6340e | 2348 | // The LedWiz speed setting gives the flash period in 0.25s units |
mjr | 76:7f5912b6340e | 2349 | // (speed 1 is a flash period of .25s, speed 7 is a period of 1.75s). |
mjr | 76:7f5912b6340e | 2350 | // |
mjr | 76:7f5912b6340e | 2351 | // What we're after here is the "phase", which is to say the point |
mjr | 76:7f5912b6340e | 2352 | // in the current cycle. If we assume that the cycle has been running |
mjr | 76:7f5912b6340e | 2353 | // continuously since some arbitrary time zero in the past, we can |
mjr | 76:7f5912b6340e | 2354 | // figure where we are in the current cycle by dividing the time since |
mjr | 76:7f5912b6340e | 2355 | // that zero by the cycle period and taking the remainder. E.g., if |
mjr | 76:7f5912b6340e | 2356 | // the cycle time is 5 seconds, and the time since t-zero is 17 seconds, |
mjr | 76:7f5912b6340e | 2357 | // we divide 17 by 5 to get a remainder of 2. That says we're 2 seconds |
mjr | 76:7f5912b6340e | 2358 | // into the current 5-second cycle, or 2/5 of the way through the |
mjr | 76:7f5912b6340e | 2359 | // current cycle. |
mjr | 76:7f5912b6340e | 2360 | // |
mjr | 76:7f5912b6340e | 2361 | // We do this calculation on every iteration of the main loop, so we |
mjr | 76:7f5912b6340e | 2362 | // want it to be very fast. To streamline it, we'll use some tricky |
mjr | 76:7f5912b6340e | 2363 | // integer arithmetic. The result will be the same as the straightforward |
mjr | 76:7f5912b6340e | 2364 | // remainder and fraction calculation we just explained, but we'll get |
mjr | 76:7f5912b6340e | 2365 | // there by less-than-obvious means. |
mjr | 76:7f5912b6340e | 2366 | // |
mjr | 76:7f5912b6340e | 2367 | // Rather than finding the phase as a continuous quantity or floating |
mjr | 76:7f5912b6340e | 2368 | // point number, we'll quantize it. We'll divide each cycle into 256 |
mjr | 76:7f5912b6340e | 2369 | // time units, or quanta. Each quantum is 1/256 of the cycle length, |
mjr | 76:7f5912b6340e | 2370 | // so for a 1-second cycle (LedWiz speed 4), each quantum is 1/256 of |
mjr | 76:7f5912b6340e | 2371 | // a second, or about 3.9ms. If we express the time since t-zero in |
mjr | 76:7f5912b6340e | 2372 | // these units, the time period of one cycle is exactly 256 units, so |
mjr | 76:7f5912b6340e | 2373 | // we can calculate our point in the cycle by taking the remainder of |
mjr | 76:7f5912b6340e | 2374 | // the time (in our funny units) divided by 256. The special thing |
mjr | 76:7f5912b6340e | 2375 | // about making the cycle time equal to 256 units is that "x % 256" |
mjr | 76:7f5912b6340e | 2376 | // is exactly the same as "x & 255", which is a much faster operation |
mjr | 76:7f5912b6340e | 2377 | // than division on ARM M0+: this CPU has no hardware DIVIDE operation, |
mjr | 76:7f5912b6340e | 2378 | // so an integer division takes about 5us. The bit mask operation, in |
mjr | 76:7f5912b6340e | 2379 | // contrast, takes only about 60ns - about 100x faster. 5us doesn't |
mjr | 76:7f5912b6340e | 2380 | // sound like much, but we do this on every main loop, so every little |
mjr | 76:7f5912b6340e | 2381 | // bit counts. |
mjr | 76:7f5912b6340e | 2382 | // |
mjr | 76:7f5912b6340e | 2383 | // The snag is that our system timer gives us the elapsed time in |
mjr | 76:7f5912b6340e | 2384 | // microseconds. We still need to convert this to our special quanta |
mjr | 76:7f5912b6340e | 2385 | // of 256 units per cycle. The straightforward way to do that is by |
mjr | 76:7f5912b6340e | 2386 | // dividing by (microseconds per quantum). E.g., for LedWiz speed 4, |
mjr | 76:7f5912b6340e | 2387 | // we decided that our quantum was 1/256 of a second, or 3906us, so |
mjr | 76:7f5912b6340e | 2388 | // dividing the current system time in microseconds by 3906 will give |
mjr | 76:7f5912b6340e | 2389 | // us the time in our quantum units. But now we've just substituted |
mjr | 76:7f5912b6340e | 2390 | // one division for another! |
mjr | 76:7f5912b6340e | 2391 | // |
mjr | 76:7f5912b6340e | 2392 | // This is where our really tricky integer math comes in. Dividing |
mjr | 76:7f5912b6340e | 2393 | // by X is the same as multiplying by 1/X. In integer math, 1/3906 |
mjr | 76:7f5912b6340e | 2394 | // is zero, so that won't work. But we can get around that by doing |
mjr | 76:7f5912b6340e | 2395 | // the integer math as "fixed point" arithmetic instead. It's still |
mjr | 76:7f5912b6340e | 2396 | // actually carried out as integer operations, but we'll scale our |
mjr | 76:7f5912b6340e | 2397 | // integers by a scaling factor, then take out the scaling factor |
mjr | 76:7f5912b6340e | 2398 | // later to get the final result. The scaling factor we'll use is |
mjr | 76:7f5912b6340e | 2399 | // 2^24. So we're going to calculate (time * 2^24/3906), then divide |
mjr | 76:7f5912b6340e | 2400 | // the result by 2^24 to get the final answer. I know it seems like |
mjr | 76:7f5912b6340e | 2401 | // we're substituting one division for another yet again, but this |
mjr | 76:7f5912b6340e | 2402 | // time's the charm, because dividing by 2^24 is a bit shift operation, |
mjr | 76:7f5912b6340e | 2403 | // which is another single-cycle operation on M0+. You might also |
mjr | 76:7f5912b6340e | 2404 | // wonder how all these tricks don't cause overflows or underflows |
mjr | 76:7f5912b6340e | 2405 | // or what not. Well, the multiply by 2^24/3906 will cause an |
mjr | 76:7f5912b6340e | 2406 | // overflow, but we don't care, because the overflow will all be in |
mjr | 76:7f5912b6340e | 2407 | // the high-order bits that we're going to discard in the final |
mjr | 76:7f5912b6340e | 2408 | // remainder calculation anyway. |
mjr | 76:7f5912b6340e | 2409 | // |
mjr | 76:7f5912b6340e | 2410 | // Each entry in the array below represents 2^24/N for the corresponding |
mjr | 76:7f5912b6340e | 2411 | // LedWiz speed, where N is the number of time quanta per cycle at that |
mjr | 76:7f5912b6340e | 2412 | // speed. The time quanta are chosen such that 256 quanta add up to |
mjr | 76:7f5912b6340e | 2413 | // approximately (LedWiz speed setting * 0.25s). |
mjr | 76:7f5912b6340e | 2414 | // |
mjr | 76:7f5912b6340e | 2415 | // Note that the calculation has an implicit bit mask (result & 0xFF) |
mjr | 76:7f5912b6340e | 2416 | // to get the final result mod 256. But we don't have to actually |
mjr | 76:7f5912b6340e | 2417 | // do that work because we're using 32-bit ints and a 2^24 fixed |
mjr | 76:7f5912b6340e | 2418 | // point base (X in the narrative above). The final shift right by |
mjr | 76:7f5912b6340e | 2419 | // 24 bits to divide out the base will leave us with only 8 bits in |
mjr | 76:7f5912b6340e | 2420 | // the result, since we started with 32. |
mjr | 76:7f5912b6340e | 2421 | static const uint32_t inv_us_per_quantum[] = { // indexed by LedWiz speed |
mjr | 76:7f5912b6340e | 2422 | 0, 17172, 8590, 5726, 4295, 3436, 2863, 2454 |
mjr | 76:7f5912b6340e | 2423 | }; |
mjr | 76:7f5912b6340e | 2424 | int counter = ((wizCycleTimer.read_us() * inv_us_per_quantum[wizSpeed[wizPulseBank]]) >> 24); |
mjr | 76:7f5912b6340e | 2425 | |
mjr | 76:7f5912b6340e | 2426 | // get the range of 32 output sin this bank |
mjr | 76:7f5912b6340e | 2427 | int fromPort = wizPulseBank*32; |
mjr | 76:7f5912b6340e | 2428 | int toPort = fromPort+32; |
mjr | 76:7f5912b6340e | 2429 | if (toPort > numOutputs) |
mjr | 76:7f5912b6340e | 2430 | toPort = numOutputs; |
mjr | 76:7f5912b6340e | 2431 | |
mjr | 76:7f5912b6340e | 2432 | // update all outputs set to flashing values |
mjr | 76:7f5912b6340e | 2433 | for (int i = fromPort ; i < toPort ; ++i) |
mjr | 73:4e8ce0b18915 | 2434 | { |
mjr | 76:7f5912b6340e | 2435 | // Update the port only if the LedWiz SBA switch for the port is on |
mjr | 76:7f5912b6340e | 2436 | // (wizOn[i]) AND the port is a PBA flash mode in the range 129..132. |
mjr | 76:7f5912b6340e | 2437 | // These modes and only these modes have the high bit (0x80) set, so |
mjr | 76:7f5912b6340e | 2438 | // we can test for them simply by testing the high bit. |
mjr | 76:7f5912b6340e | 2439 | if (wizOn[i]) |
mjr | 29:582472d0bc57 | 2440 | { |
mjr | 76:7f5912b6340e | 2441 | uint8_t val = wizVal[i]; |
mjr | 76:7f5912b6340e | 2442 | if ((val & 0x80) != 0) |
mjr | 29:582472d0bc57 | 2443 | { |
mjr | 76:7f5912b6340e | 2444 | // ook up the value for the mode at the cycle time |
mjr | 76:7f5912b6340e | 2445 | lwPin[i]->set(outLevel[i] = wizFlashLookup[((val-129) << 8) + counter]); |
mjr | 29:582472d0bc57 | 2446 | } |
mjr | 29:582472d0bc57 | 2447 | } |
mjr | 76:7f5912b6340e | 2448 | } |
mjr | 76:7f5912b6340e | 2449 | |
mjr | 34:6b981a2afab7 | 2450 | // flush changes to 74HC595 chips, if attached |
mjr | 35:e959ffba78fd | 2451 | if (hc595 != 0) |
mjr | 35:e959ffba78fd | 2452 | hc595->update(); |
mjr | 76:7f5912b6340e | 2453 | |
mjr | 76:7f5912b6340e | 2454 | // switch to the next bank |
mjr | 76:7f5912b6340e | 2455 | if (++wizPulseBank >= MAX_LW_BANKS) |
mjr | 76:7f5912b6340e | 2456 | wizPulseBank = 0; |
mjr | 76:7f5912b6340e | 2457 | |
mjr | 76:7f5912b6340e | 2458 | // collect timing statistics |
mjr | 76:7f5912b6340e | 2459 | IF_DIAG( |
mjr | 76:7f5912b6340e | 2460 | wizPulseTotalTime += t.read_us(); |
mjr | 76:7f5912b6340e | 2461 | wizPulseRunCount += 1; |
mjr | 76:7f5912b6340e | 2462 | ) |
mjr | 1:d913e0afb2ac | 2463 | } |
mjr | 38:091e511ce8a0 | 2464 | |
mjr | 76:7f5912b6340e | 2465 | // Update a port to reflect its new LedWiz SBA+PBA setting. |
mjr | 76:7f5912b6340e | 2466 | static void updateLwPort(int port) |
mjr | 38:091e511ce8a0 | 2467 | { |
mjr | 76:7f5912b6340e | 2468 | // check if the SBA switch is on or off |
mjr | 76:7f5912b6340e | 2469 | if (wizOn[port]) |
mjr | 76:7f5912b6340e | 2470 | { |
mjr | 76:7f5912b6340e | 2471 | // It's on. If the port is a valid static brightness level, |
mjr | 76:7f5912b6340e | 2472 | // set the output port to match. Otherwise leave it as is: |
mjr | 76:7f5912b6340e | 2473 | // if it's a flashing mode, the flash mode pulse will update |
mjr | 76:7f5912b6340e | 2474 | // it on the next cycle. |
mjr | 76:7f5912b6340e | 2475 | int val = wizVal[port]; |
mjr | 76:7f5912b6340e | 2476 | if (val <= 49) |
mjr | 76:7f5912b6340e | 2477 | lwPin[port]->set(outLevel[port] = lw_to_dof[val]); |
mjr | 76:7f5912b6340e | 2478 | } |
mjr | 76:7f5912b6340e | 2479 | else |
mjr | 76:7f5912b6340e | 2480 | { |
mjr | 76:7f5912b6340e | 2481 | // the port is off - set absolute brightness zero |
mjr | 76:7f5912b6340e | 2482 | lwPin[port]->set(outLevel[port] = 0); |
mjr | 76:7f5912b6340e | 2483 | } |
mjr | 73:4e8ce0b18915 | 2484 | } |
mjr | 73:4e8ce0b18915 | 2485 | |
mjr | 73:4e8ce0b18915 | 2486 | // Turn off all outputs and restore everything to the default LedWiz |
mjr | 92:f264fbaa1be5 | 2487 | // state. This sets all outputs to LedWiz profile value 48 (full |
mjr | 92:f264fbaa1be5 | 2488 | // brightness) and switch state Off, and sets the LedWiz flash rate |
mjr | 92:f264fbaa1be5 | 2489 | // to 2. This effectively restores the power-on conditions. |
mjr | 73:4e8ce0b18915 | 2490 | // |
mjr | 73:4e8ce0b18915 | 2491 | void allOutputsOff() |
mjr | 73:4e8ce0b18915 | 2492 | { |
mjr | 92:f264fbaa1be5 | 2493 | // reset all outputs to OFF/48 |
mjr | 73:4e8ce0b18915 | 2494 | for (int i = 0 ; i < numOutputs ; ++i) |
mjr | 73:4e8ce0b18915 | 2495 | { |
mjr | 73:4e8ce0b18915 | 2496 | outLevel[i] = 0; |
mjr | 73:4e8ce0b18915 | 2497 | wizOn[i] = 0; |
mjr | 73:4e8ce0b18915 | 2498 | wizVal[i] = 48; |
mjr | 73:4e8ce0b18915 | 2499 | lwPin[i]->set(0); |
mjr | 73:4e8ce0b18915 | 2500 | } |
mjr | 73:4e8ce0b18915 | 2501 | |
mjr | 73:4e8ce0b18915 | 2502 | // restore default LedWiz flash rate |
mjr | 73:4e8ce0b18915 | 2503 | for (int i = 0 ; i < countof(wizSpeed) ; ++i) |
mjr | 73:4e8ce0b18915 | 2504 | wizSpeed[i] = 2; |
mjr | 38:091e511ce8a0 | 2505 | |
mjr | 73:4e8ce0b18915 | 2506 | // flush changes to hc595, if applicable |
mjr | 38:091e511ce8a0 | 2507 | if (hc595 != 0) |
mjr | 38:091e511ce8a0 | 2508 | hc595->update(); |
mjr | 38:091e511ce8a0 | 2509 | } |
mjr | 38:091e511ce8a0 | 2510 | |
mjr | 74:822a92bc11d2 | 2511 | // Cary out an SBA or SBX message. portGroup is 0 for ports 1-32, |
mjr | 74:822a92bc11d2 | 2512 | // 1 for ports 33-64, etc. Original protocol SBA messages always |
mjr | 74:822a92bc11d2 | 2513 | // address port group 0; our private SBX extension messages can |
mjr | 74:822a92bc11d2 | 2514 | // address any port group. |
mjr | 74:822a92bc11d2 | 2515 | void sba_sbx(int portGroup, const uint8_t *data) |
mjr | 74:822a92bc11d2 | 2516 | { |
mjr | 76:7f5912b6340e | 2517 | // update all on/off states in the group |
mjr | 74:822a92bc11d2 | 2518 | for (int i = 0, bit = 1, imsg = 1, port = portGroup*32 ; |
mjr | 74:822a92bc11d2 | 2519 | i < 32 && port < numOutputs ; |
mjr | 74:822a92bc11d2 | 2520 | ++i, bit <<= 1, ++port) |
mjr | 74:822a92bc11d2 | 2521 | { |
mjr | 74:822a92bc11d2 | 2522 | // figure the on/off state bit for this output |
mjr | 74:822a92bc11d2 | 2523 | if (bit == 0x100) { |
mjr | 74:822a92bc11d2 | 2524 | bit = 1; |
mjr | 74:822a92bc11d2 | 2525 | ++imsg; |
mjr | 74:822a92bc11d2 | 2526 | } |
mjr | 74:822a92bc11d2 | 2527 | |
mjr | 74:822a92bc11d2 | 2528 | // set the on/off state |
mjr | 76:7f5912b6340e | 2529 | bool on = wizOn[port] = ((data[imsg] & bit) != 0); |
mjr | 76:7f5912b6340e | 2530 | |
mjr | 76:7f5912b6340e | 2531 | // set the output port brightness to match the new setting |
mjr | 76:7f5912b6340e | 2532 | updateLwPort(port); |
mjr | 74:822a92bc11d2 | 2533 | } |
mjr | 74:822a92bc11d2 | 2534 | |
mjr | 74:822a92bc11d2 | 2535 | // set the flash speed for the port group |
mjr | 74:822a92bc11d2 | 2536 | if (portGroup < countof(wizSpeed)) |
mjr | 74:822a92bc11d2 | 2537 | wizSpeed[portGroup] = (data[5] < 1 ? 1 : data[5] > 7 ? 7 : data[5]); |
mjr | 74:822a92bc11d2 | 2538 | |
mjr | 76:7f5912b6340e | 2539 | // update 74HC959 outputs |
mjr | 76:7f5912b6340e | 2540 | if (hc595 != 0) |
mjr | 76:7f5912b6340e | 2541 | hc595->update(); |
mjr | 74:822a92bc11d2 | 2542 | } |
mjr | 74:822a92bc11d2 | 2543 | |
mjr | 74:822a92bc11d2 | 2544 | // Carry out a PBA or PBX message. |
mjr | 74:822a92bc11d2 | 2545 | void pba_pbx(int basePort, const uint8_t *data) |
mjr | 74:822a92bc11d2 | 2546 | { |
mjr | 74:822a92bc11d2 | 2547 | // update each wizVal entry from the brightness data |
mjr | 76:7f5912b6340e | 2548 | for (int i = 0, port = basePort ; i < 8 && port < numOutputs ; ++i, ++port) |
mjr | 74:822a92bc11d2 | 2549 | { |
mjr | 74:822a92bc11d2 | 2550 | // get the value |
mjr | 74:822a92bc11d2 | 2551 | uint8_t v = data[i]; |
mjr | 74:822a92bc11d2 | 2552 | |
mjr | 74:822a92bc11d2 | 2553 | // Validate it. The legal values are 0..49 for brightness |
mjr | 74:822a92bc11d2 | 2554 | // levels, and 128..132 for flash modes. Set anything invalid |
mjr | 74:822a92bc11d2 | 2555 | // to full brightness (48) instead. Note that 49 isn't actually |
mjr | 74:822a92bc11d2 | 2556 | // a valid documented value, but in practice some clients send |
mjr | 74:822a92bc11d2 | 2557 | // this to mean 100% brightness, and the real LedWiz treats it |
mjr | 74:822a92bc11d2 | 2558 | // as such. |
mjr | 74:822a92bc11d2 | 2559 | if ((v > 49 && v < 129) || v > 132) |
mjr | 74:822a92bc11d2 | 2560 | v = 48; |
mjr | 74:822a92bc11d2 | 2561 | |
mjr | 74:822a92bc11d2 | 2562 | // store it |
mjr | 76:7f5912b6340e | 2563 | wizVal[port] = v; |
mjr | 76:7f5912b6340e | 2564 | |
mjr | 76:7f5912b6340e | 2565 | // update the port |
mjr | 76:7f5912b6340e | 2566 | updateLwPort(port); |
mjr | 74:822a92bc11d2 | 2567 | } |
mjr | 74:822a92bc11d2 | 2568 | |
mjr | 76:7f5912b6340e | 2569 | // update 74HC595 outputs |
mjr | 76:7f5912b6340e | 2570 | if (hc595 != 0) |
mjr | 76:7f5912b6340e | 2571 | hc595->update(); |
mjr | 74:822a92bc11d2 | 2572 | } |
mjr | 74:822a92bc11d2 | 2573 | |
mjr | 77:0b96f6867312 | 2574 | // --------------------------------------------------------------------------- |
mjr | 77:0b96f6867312 | 2575 | // |
mjr | 77:0b96f6867312 | 2576 | // IR Remote Control transmitter & receiver |
mjr | 77:0b96f6867312 | 2577 | // |
mjr | 77:0b96f6867312 | 2578 | |
mjr | 77:0b96f6867312 | 2579 | // receiver |
mjr | 77:0b96f6867312 | 2580 | IRReceiver *ir_rx; |
mjr | 77:0b96f6867312 | 2581 | |
mjr | 77:0b96f6867312 | 2582 | // transmitter |
mjr | 77:0b96f6867312 | 2583 | IRTransmitter *ir_tx; |
mjr | 77:0b96f6867312 | 2584 | |
mjr | 77:0b96f6867312 | 2585 | // Mapping from IR commands slots in the configuration to "virtual button" |
mjr | 77:0b96f6867312 | 2586 | // numbers on the IRTransmitter's "virtual remote". To minimize RAM usage, |
mjr | 77:0b96f6867312 | 2587 | // we only create virtual buttons on the transmitter object for code slots |
mjr | 77:0b96f6867312 | 2588 | // that are configured for transmission, which includes slots used for TV |
mjr | 77:0b96f6867312 | 2589 | // ON commands and slots that can be triggered by button presses. This |
mjr | 77:0b96f6867312 | 2590 | // means that virtual button numbers won't necessarily match the config |
mjr | 77:0b96f6867312 | 2591 | // slot numbers. This table provides the mapping: |
mjr | 77:0b96f6867312 | 2592 | // IRConfigSlotToVirtualButton[n] = ir_tx virtual button number for |
mjr | 77:0b96f6867312 | 2593 | // configuration slot n |
mjr | 77:0b96f6867312 | 2594 | uint8_t IRConfigSlotToVirtualButton[MAX_IR_CODES]; |
mjr | 78:1e00b3fa11af | 2595 | |
mjr | 78:1e00b3fa11af | 2596 | // IR transmitter virtual button number for ad hoc IR command. We allocate |
mjr | 78:1e00b3fa11af | 2597 | // one virtual button for sending ad hoc IR codes, such as through the USB |
mjr | 78:1e00b3fa11af | 2598 | // protocol. |
mjr | 78:1e00b3fa11af | 2599 | uint8_t IRAdHocBtn; |
mjr | 78:1e00b3fa11af | 2600 | |
mjr | 78:1e00b3fa11af | 2601 | // Staging area for ad hoc IR commands. It takes multiple messages |
mjr | 78:1e00b3fa11af | 2602 | // to fill out an IR command, so we store the partial command here |
mjr | 78:1e00b3fa11af | 2603 | // while waiting for the rest. |
mjr | 78:1e00b3fa11af | 2604 | static struct |
mjr | 78:1e00b3fa11af | 2605 | { |
mjr | 78:1e00b3fa11af | 2606 | uint8_t protocol; // protocol ID |
mjr | 78:1e00b3fa11af | 2607 | uint64_t code; // code |
mjr | 78:1e00b3fa11af | 2608 | uint8_t dittos : 1; // using dittos? |
mjr | 78:1e00b3fa11af | 2609 | uint8_t ready : 1; // do we have a code ready to transmit? |
mjr | 78:1e00b3fa11af | 2610 | } IRAdHocCmd; |
mjr | 88:98bce687e6c0 | 2611 | |
mjr | 77:0b96f6867312 | 2612 | |
mjr | 77:0b96f6867312 | 2613 | // IR mode timer. In normal mode, this is the time since the last |
mjr | 77:0b96f6867312 | 2614 | // command received; we use this to handle commands with timed effects, |
mjr | 77:0b96f6867312 | 2615 | // such as sending a key to the PC. In learning mode, this is the time |
mjr | 77:0b96f6867312 | 2616 | // since we activated learning mode, which we use to automatically end |
mjr | 77:0b96f6867312 | 2617 | // learning mode if a decodable command isn't received within a reasonable |
mjr | 77:0b96f6867312 | 2618 | // amount of time. |
mjr | 77:0b96f6867312 | 2619 | Timer IRTimer; |
mjr | 77:0b96f6867312 | 2620 | |
mjr | 77:0b96f6867312 | 2621 | // IR Learning Mode. The PC enters learning mode via special function 65 12. |
mjr | 77:0b96f6867312 | 2622 | // The states are: |
mjr | 77:0b96f6867312 | 2623 | // |
mjr | 77:0b96f6867312 | 2624 | // 0 -> normal operation (not in learning mode) |
mjr | 77:0b96f6867312 | 2625 | // 1 -> learning mode; reading raw codes, no command read yet |
mjr | 77:0b96f6867312 | 2626 | // 2 -> learning mode; command received, awaiting auto-repeat |
mjr | 77:0b96f6867312 | 2627 | // 3 -> learning mode; done, command and repeat mode decoded |
mjr | 77:0b96f6867312 | 2628 | // |
mjr | 77:0b96f6867312 | 2629 | // When we enter learning mode, we reset IRTimer to keep track of how long |
mjr | 77:0b96f6867312 | 2630 | // we've been in the mode. This allows the mode to time out if no code is |
mjr | 77:0b96f6867312 | 2631 | // received within a reasonable time. |
mjr | 77:0b96f6867312 | 2632 | uint8_t IRLearningMode = 0; |
mjr | 77:0b96f6867312 | 2633 | |
mjr | 77:0b96f6867312 | 2634 | // Learning mode command received. This stores the first decoded command |
mjr | 77:0b96f6867312 | 2635 | // when in learning mode. For some protocols, we can't just report the |
mjr | 77:0b96f6867312 | 2636 | // first command we receive, because we need to wait for an auto-repeat to |
mjr | 77:0b96f6867312 | 2637 | // determine what format the remote uses for repeats. This stores the first |
mjr | 77:0b96f6867312 | 2638 | // command while we await a repeat. This is necessary for protocols that |
mjr | 77:0b96f6867312 | 2639 | // have "dittos", since some remotes for such protocols use the dittos and |
mjr | 77:0b96f6867312 | 2640 | // some don't; the only way to find out is to read a repeat code and see if |
mjr | 77:0b96f6867312 | 2641 | // it's a ditto or just a repeat of the full code. |
mjr | 77:0b96f6867312 | 2642 | IRCommand learnedIRCode; |
mjr | 77:0b96f6867312 | 2643 | |
mjr | 78:1e00b3fa11af | 2644 | // IR command received, as a config slot index, 1..MAX_IR_CODES. |
mjr | 77:0b96f6867312 | 2645 | // When we receive a command that matches one of our programmed commands, |
mjr | 77:0b96f6867312 | 2646 | // we note the slot here. We also reset the IR timer so that we know how |
mjr | 77:0b96f6867312 | 2647 | // long it's been since the command came in. This lets us handle commands |
mjr | 77:0b96f6867312 | 2648 | // with timed effects, such as PC key input. Note that this is a 1-based |
mjr | 77:0b96f6867312 | 2649 | // index; 0 represents no command. |
mjr | 77:0b96f6867312 | 2650 | uint8_t IRCommandIn = 0; |
mjr | 77:0b96f6867312 | 2651 | |
mjr | 77:0b96f6867312 | 2652 | // "Toggle bit" of last command. Some IR protocols have a toggle bit |
mjr | 77:0b96f6867312 | 2653 | // that distinguishes an auto-repeating key from a key being pressed |
mjr | 77:0b96f6867312 | 2654 | // several times in a row. This records the toggle bit of the last |
mjr | 77:0b96f6867312 | 2655 | // command we received. |
mjr | 77:0b96f6867312 | 2656 | uint8_t lastIRToggle = 0; |
mjr | 77:0b96f6867312 | 2657 | |
mjr | 77:0b96f6867312 | 2658 | // Are we in a gap between successive key presses? When we detect that a |
mjr | 77:0b96f6867312 | 2659 | // key is being pressed multiple times rather than auto-repeated (which we |
mjr | 77:0b96f6867312 | 2660 | // can detect via a toggle bit in some protocols), we'll briefly stop sending |
mjr | 77:0b96f6867312 | 2661 | // the associated key to the PC, so that the PC likewise recognizes the |
mjr | 77:0b96f6867312 | 2662 | // distinct key press. |
mjr | 77:0b96f6867312 | 2663 | uint8_t IRKeyGap = false; |
mjr | 77:0b96f6867312 | 2664 | |
mjr | 78:1e00b3fa11af | 2665 | |
mjr | 77:0b96f6867312 | 2666 | // initialize |
mjr | 77:0b96f6867312 | 2667 | void init_IR(Config &cfg, bool &kbKeys) |
mjr | 77:0b96f6867312 | 2668 | { |
mjr | 77:0b96f6867312 | 2669 | PinName pin; |
mjr | 77:0b96f6867312 | 2670 | |
mjr | 77:0b96f6867312 | 2671 | // start the IR timer |
mjr | 77:0b96f6867312 | 2672 | IRTimer.start(); |
mjr | 77:0b96f6867312 | 2673 | |
mjr | 77:0b96f6867312 | 2674 | // if there's a transmitter, set it up |
mjr | 77:0b96f6867312 | 2675 | if ((pin = wirePinName(cfg.IR.emitter)) != NC) |
mjr | 77:0b96f6867312 | 2676 | { |
mjr | 77:0b96f6867312 | 2677 | // no virtual buttons yet |
mjr | 77:0b96f6867312 | 2678 | int nVirtualButtons = 0; |
mjr | 77:0b96f6867312 | 2679 | memset(IRConfigSlotToVirtualButton, 0xFF, sizeof(IRConfigSlotToVirtualButton)); |
mjr | 77:0b96f6867312 | 2680 | |
mjr | 77:0b96f6867312 | 2681 | // assign virtual buttons slots for TV ON codes |
mjr | 77:0b96f6867312 | 2682 | for (int i = 0 ; i < MAX_IR_CODES ; ++i) |
mjr | 77:0b96f6867312 | 2683 | { |
mjr | 77:0b96f6867312 | 2684 | if ((cfg.IRCommand[i].flags & IRFlagTVON) != 0) |
mjr | 77:0b96f6867312 | 2685 | IRConfigSlotToVirtualButton[i] = nVirtualButtons++; |
mjr | 77:0b96f6867312 | 2686 | } |
mjr | 77:0b96f6867312 | 2687 | |
mjr | 77:0b96f6867312 | 2688 | // assign virtual buttons for codes that can be triggered by |
mjr | 77:0b96f6867312 | 2689 | // real button inputs |
mjr | 77:0b96f6867312 | 2690 | for (int i = 0 ; i < MAX_BUTTONS ; ++i) |
mjr | 77:0b96f6867312 | 2691 | { |
mjr | 77:0b96f6867312 | 2692 | // get the button |
mjr | 77:0b96f6867312 | 2693 | ButtonCfg &b = cfg.button[i]; |
mjr | 77:0b96f6867312 | 2694 | |
mjr | 77:0b96f6867312 | 2695 | // check the unshifted button |
mjr | 77:0b96f6867312 | 2696 | int c = b.IRCommand - 1; |
mjr | 77:0b96f6867312 | 2697 | if (c >= 0 && c < MAX_IR_CODES |
mjr | 77:0b96f6867312 | 2698 | && IRConfigSlotToVirtualButton[c] == 0xFF) |
mjr | 77:0b96f6867312 | 2699 | IRConfigSlotToVirtualButton[c] = nVirtualButtons++; |
mjr | 77:0b96f6867312 | 2700 | |
mjr | 77:0b96f6867312 | 2701 | // check the shifted button |
mjr | 77:0b96f6867312 | 2702 | c = b.IRCommand2 - 1; |
mjr | 77:0b96f6867312 | 2703 | if (c >= 0 && c < MAX_IR_CODES |
mjr | 77:0b96f6867312 | 2704 | && IRConfigSlotToVirtualButton[c] == 0xFF) |
mjr | 77:0b96f6867312 | 2705 | IRConfigSlotToVirtualButton[c] = nVirtualButtons++; |
mjr | 77:0b96f6867312 | 2706 | } |
mjr | 77:0b96f6867312 | 2707 | |
mjr | 77:0b96f6867312 | 2708 | // allocate an additional virtual button for transmitting ad hoc |
mjr | 77:0b96f6867312 | 2709 | // codes, such as for the "send code" USB API function |
mjr | 78:1e00b3fa11af | 2710 | IRAdHocBtn = nVirtualButtons++; |
mjr | 77:0b96f6867312 | 2711 | |
mjr | 77:0b96f6867312 | 2712 | // create the transmitter |
mjr | 77:0b96f6867312 | 2713 | ir_tx = new IRTransmitter(pin, nVirtualButtons); |
mjr | 77:0b96f6867312 | 2714 | |
mjr | 77:0b96f6867312 | 2715 | // program the commands into the virtual button slots |
mjr | 77:0b96f6867312 | 2716 | for (int i = 0 ; i < MAX_IR_CODES ; ++i) |
mjr | 77:0b96f6867312 | 2717 | { |
mjr | 77:0b96f6867312 | 2718 | // if this slot is assigned to a virtual button, program it |
mjr | 77:0b96f6867312 | 2719 | int vb = IRConfigSlotToVirtualButton[i]; |
mjr | 77:0b96f6867312 | 2720 | if (vb != 0xFF) |
mjr | 77:0b96f6867312 | 2721 | { |
mjr | 77:0b96f6867312 | 2722 | IRCommandCfg &cb = cfg.IRCommand[i]; |
mjr | 77:0b96f6867312 | 2723 | uint64_t code = cb.code.lo | (uint64_t(cb.code.hi) << 32); |
mjr | 77:0b96f6867312 | 2724 | bool dittos = (cb.flags & IRFlagDittos) != 0; |
mjr | 77:0b96f6867312 | 2725 | ir_tx->programButton(vb, cb.protocol, dittos, code); |
mjr | 77:0b96f6867312 | 2726 | } |
mjr | 77:0b96f6867312 | 2727 | } |
mjr | 77:0b96f6867312 | 2728 | } |
mjr | 77:0b96f6867312 | 2729 | |
mjr | 77:0b96f6867312 | 2730 | // if there's a receiver, set it up |
mjr | 77:0b96f6867312 | 2731 | if ((pin = wirePinName(cfg.IR.sensor)) != NC) |
mjr | 77:0b96f6867312 | 2732 | { |
mjr | 77:0b96f6867312 | 2733 | // create the receiver |
mjr | 77:0b96f6867312 | 2734 | ir_rx = new IRReceiver(pin, 32); |
mjr | 77:0b96f6867312 | 2735 | |
mjr | 77:0b96f6867312 | 2736 | // connect the transmitter (if any) to the receiver, so that |
mjr | 77:0b96f6867312 | 2737 | // the receiver can suppress reception of our own transmissions |
mjr | 77:0b96f6867312 | 2738 | ir_rx->setTransmitter(ir_tx); |
mjr | 77:0b96f6867312 | 2739 | |
mjr | 77:0b96f6867312 | 2740 | // enable it |
mjr | 77:0b96f6867312 | 2741 | ir_rx->enable(); |
mjr | 77:0b96f6867312 | 2742 | |
mjr | 77:0b96f6867312 | 2743 | // Check the IR command slots to see if any slots are configured |
mjr | 77:0b96f6867312 | 2744 | // to send a keyboard key on receiving an IR command. If any are, |
mjr | 77:0b96f6867312 | 2745 | // tell the caller that we need a USB keyboard interface. |
mjr | 77:0b96f6867312 | 2746 | for (int i = 0 ; i < MAX_IR_CODES ; ++i) |
mjr | 77:0b96f6867312 | 2747 | { |
mjr | 77:0b96f6867312 | 2748 | IRCommandCfg &cb = cfg.IRCommand[i]; |
mjr | 77:0b96f6867312 | 2749 | if (cb.protocol != 0 |
mjr | 77:0b96f6867312 | 2750 | && (cb.keytype == BtnTypeKey || cb.keytype == BtnTypeMedia)) |
mjr | 77:0b96f6867312 | 2751 | { |
mjr | 77:0b96f6867312 | 2752 | kbKeys = true; |
mjr | 77:0b96f6867312 | 2753 | break; |
mjr | 77:0b96f6867312 | 2754 | } |
mjr | 77:0b96f6867312 | 2755 | } |
mjr | 77:0b96f6867312 | 2756 | } |
mjr | 77:0b96f6867312 | 2757 | } |
mjr | 77:0b96f6867312 | 2758 | |
mjr | 77:0b96f6867312 | 2759 | // Press or release a button with an assigned IR function. 'cmd' |
mjr | 77:0b96f6867312 | 2760 | // is the command slot number (1..MAX_IR_CODES) assigned to the button. |
mjr | 77:0b96f6867312 | 2761 | void IR_buttonChange(uint8_t cmd, bool pressed) |
mjr | 77:0b96f6867312 | 2762 | { |
mjr | 77:0b96f6867312 | 2763 | // only proceed if there's an IR transmitter attached |
mjr | 77:0b96f6867312 | 2764 | if (ir_tx != 0) |
mjr | 77:0b96f6867312 | 2765 | { |
mjr | 77:0b96f6867312 | 2766 | // adjust the command slot to a zero-based index |
mjr | 77:0b96f6867312 | 2767 | int slot = cmd - 1; |
mjr | 77:0b96f6867312 | 2768 | |
mjr | 77:0b96f6867312 | 2769 | // press or release the virtual button |
mjr | 77:0b96f6867312 | 2770 | ir_tx->pushButton(IRConfigSlotToVirtualButton[slot], pressed); |
mjr | 77:0b96f6867312 | 2771 | } |
mjr | 77:0b96f6867312 | 2772 | } |
mjr | 77:0b96f6867312 | 2773 | |
mjr | 78:1e00b3fa11af | 2774 | // Process IR input and output |
mjr | 77:0b96f6867312 | 2775 | void process_IR(Config &cfg, USBJoystick &js) |
mjr | 77:0b96f6867312 | 2776 | { |
mjr | 78:1e00b3fa11af | 2777 | // check for transmitter tasks, if there's a transmitter |
mjr | 78:1e00b3fa11af | 2778 | if (ir_tx != 0) |
mjr | 77:0b96f6867312 | 2779 | { |
mjr | 78:1e00b3fa11af | 2780 | // If we're not currently sending, and an ad hoc IR command |
mjr | 78:1e00b3fa11af | 2781 | // is ready to send, send it. |
mjr | 78:1e00b3fa11af | 2782 | if (!ir_tx->isSending() && IRAdHocCmd.ready) |
mjr | 78:1e00b3fa11af | 2783 | { |
mjr | 78:1e00b3fa11af | 2784 | // program the command into the transmitter virtual button |
mjr | 78:1e00b3fa11af | 2785 | // that we reserved for ad hoc commands |
mjr | 78:1e00b3fa11af | 2786 | ir_tx->programButton(IRAdHocBtn, IRAdHocCmd.protocol, |
mjr | 78:1e00b3fa11af | 2787 | IRAdHocCmd.dittos, IRAdHocCmd.code); |
mjr | 78:1e00b3fa11af | 2788 | |
mjr | 78:1e00b3fa11af | 2789 | // send the command - just pulse the button to send it once |
mjr | 78:1e00b3fa11af | 2790 | ir_tx->pushButton(IRAdHocBtn, true); |
mjr | 78:1e00b3fa11af | 2791 | ir_tx->pushButton(IRAdHocBtn, false); |
mjr | 78:1e00b3fa11af | 2792 | |
mjr | 78:1e00b3fa11af | 2793 | // we've sent the command, so clear the 'ready' flag |
mjr | 78:1e00b3fa11af | 2794 | IRAdHocCmd.ready = false; |
mjr | 78:1e00b3fa11af | 2795 | } |
mjr | 77:0b96f6867312 | 2796 | } |
mjr | 78:1e00b3fa11af | 2797 | |
mjr | 78:1e00b3fa11af | 2798 | // check for receiver tasks, if there's a receiver |
mjr | 78:1e00b3fa11af | 2799 | if (ir_rx != 0) |
mjr | 77:0b96f6867312 | 2800 | { |
mjr | 78:1e00b3fa11af | 2801 | // Time out any received command |
mjr | 78:1e00b3fa11af | 2802 | if (IRCommandIn != 0) |
mjr | 78:1e00b3fa11af | 2803 | { |
mjr | 80:94dc2946871b | 2804 | // Time out commands after 200ms without a repeat signal. |
mjr | 80:94dc2946871b | 2805 | // Time out the inter-key gap after 50ms. |
mjr | 78:1e00b3fa11af | 2806 | uint32_t t = IRTimer.read_us(); |
mjr | 80:94dc2946871b | 2807 | if (t > 200000) |
mjr | 78:1e00b3fa11af | 2808 | IRCommandIn = 0; |
mjr | 80:94dc2946871b | 2809 | else if (t > 50000) |
mjr | 78:1e00b3fa11af | 2810 | IRKeyGap = false; |
mjr | 78:1e00b3fa11af | 2811 | } |
mjr | 78:1e00b3fa11af | 2812 | |
mjr | 78:1e00b3fa11af | 2813 | // Check if we're in learning mode |
mjr | 78:1e00b3fa11af | 2814 | if (IRLearningMode != 0) |
mjr | 78:1e00b3fa11af | 2815 | { |
mjr | 78:1e00b3fa11af | 2816 | // Learning mode. Read raw inputs from the IR sensor and |
mjr | 78:1e00b3fa11af | 2817 | // forward them to the PC via USB reports, up to the report |
mjr | 78:1e00b3fa11af | 2818 | // limit. |
mjr | 78:1e00b3fa11af | 2819 | const int nmax = USBJoystick::maxRawIR; |
mjr | 78:1e00b3fa11af | 2820 | uint16_t raw[nmax]; |
mjr | 78:1e00b3fa11af | 2821 | int n; |
mjr | 78:1e00b3fa11af | 2822 | for (n = 0 ; n < nmax && ir_rx->processOne(raw[n]) ; ++n) ; |
mjr | 77:0b96f6867312 | 2823 | |
mjr | 78:1e00b3fa11af | 2824 | // if we read any raw samples, report them |
mjr | 78:1e00b3fa11af | 2825 | if (n != 0) |
mjr | 78:1e00b3fa11af | 2826 | js.reportRawIR(n, raw); |
mjr | 77:0b96f6867312 | 2827 | |
mjr | 78:1e00b3fa11af | 2828 | // check for a command |
mjr | 78:1e00b3fa11af | 2829 | IRCommand c; |
mjr | 78:1e00b3fa11af | 2830 | if (ir_rx->readCommand(c)) |
mjr | 78:1e00b3fa11af | 2831 | { |
mjr | 78:1e00b3fa11af | 2832 | // check the current learning state |
mjr | 78:1e00b3fa11af | 2833 | switch (IRLearningMode) |
mjr | 78:1e00b3fa11af | 2834 | { |
mjr | 78:1e00b3fa11af | 2835 | case 1: |
mjr | 78:1e00b3fa11af | 2836 | // Initial state, waiting for the first decoded command. |
mjr | 78:1e00b3fa11af | 2837 | // This is it. |
mjr | 78:1e00b3fa11af | 2838 | learnedIRCode = c; |
mjr | 78:1e00b3fa11af | 2839 | |
mjr | 78:1e00b3fa11af | 2840 | // Check if we need additional information. If the |
mjr | 78:1e00b3fa11af | 2841 | // protocol supports dittos, we have to wait for a repeat |
mjr | 78:1e00b3fa11af | 2842 | // to see if the remote actually uses the dittos, since |
mjr | 78:1e00b3fa11af | 2843 | // some implementations of such protocols use the dittos |
mjr | 78:1e00b3fa11af | 2844 | // while others just send repeated full codes. Otherwise, |
mjr | 78:1e00b3fa11af | 2845 | // all we need is the initial code, so we're done. |
mjr | 78:1e00b3fa11af | 2846 | IRLearningMode = (c.hasDittos ? 2 : 3); |
mjr | 78:1e00b3fa11af | 2847 | break; |
mjr | 78:1e00b3fa11af | 2848 | |
mjr | 78:1e00b3fa11af | 2849 | case 2: |
mjr | 78:1e00b3fa11af | 2850 | // Code received, awaiting auto-repeat information. If |
mjr | 78:1e00b3fa11af | 2851 | // the protocol has dittos, check to see if we got a ditto: |
mjr | 78:1e00b3fa11af | 2852 | // |
mjr | 78:1e00b3fa11af | 2853 | // - If we received a ditto in the same protocol as the |
mjr | 78:1e00b3fa11af | 2854 | // prior command, the remote uses dittos. |
mjr | 78:1e00b3fa11af | 2855 | // |
mjr | 78:1e00b3fa11af | 2856 | // - If we received a repeat of the prior command (not a |
mjr | 78:1e00b3fa11af | 2857 | // ditto, but a repeat of the full code), the remote |
mjr | 78:1e00b3fa11af | 2858 | // doesn't use dittos even though the protocol supports |
mjr | 78:1e00b3fa11af | 2859 | // them. |
mjr | 78:1e00b3fa11af | 2860 | // |
mjr | 78:1e00b3fa11af | 2861 | // - Otherwise, it's not an auto-repeat at all, so we |
mjr | 78:1e00b3fa11af | 2862 | // can't decide one way or the other on dittos: start |
mjr | 78:1e00b3fa11af | 2863 | // over. |
mjr | 78:1e00b3fa11af | 2864 | if (c.proId == learnedIRCode.proId |
mjr | 78:1e00b3fa11af | 2865 | && c.hasDittos |
mjr | 78:1e00b3fa11af | 2866 | && c.ditto) |
mjr | 78:1e00b3fa11af | 2867 | { |
mjr | 78:1e00b3fa11af | 2868 | // success - the remote uses dittos |
mjr | 78:1e00b3fa11af | 2869 | IRLearningMode = 3; |
mjr | 78:1e00b3fa11af | 2870 | } |
mjr | 78:1e00b3fa11af | 2871 | else if (c.proId == learnedIRCode.proId |
mjr | 78:1e00b3fa11af | 2872 | && c.hasDittos |
mjr | 78:1e00b3fa11af | 2873 | && !c.ditto |
mjr | 78:1e00b3fa11af | 2874 | && c.code == learnedIRCode.code) |
mjr | 78:1e00b3fa11af | 2875 | { |
mjr | 78:1e00b3fa11af | 2876 | // success - it's a repeat of the last code, so |
mjr | 78:1e00b3fa11af | 2877 | // the remote doesn't use dittos even though the |
mjr | 78:1e00b3fa11af | 2878 | // protocol supports them |
mjr | 78:1e00b3fa11af | 2879 | learnedIRCode.hasDittos = false; |
mjr | 78:1e00b3fa11af | 2880 | IRLearningMode = 3; |
mjr | 78:1e00b3fa11af | 2881 | } |
mjr | 78:1e00b3fa11af | 2882 | else |
mjr | 78:1e00b3fa11af | 2883 | { |
mjr | 78:1e00b3fa11af | 2884 | // It's not a ditto and not a full repeat of the |
mjr | 78:1e00b3fa11af | 2885 | // last code, so it's either a new key, or some kind |
mjr | 78:1e00b3fa11af | 2886 | // of multi-code key encoding that we don't recognize. |
mjr | 78:1e00b3fa11af | 2887 | // We can't use this code, so start over. |
mjr | 78:1e00b3fa11af | 2888 | IRLearningMode = 1; |
mjr | 78:1e00b3fa11af | 2889 | } |
mjr | 78:1e00b3fa11af | 2890 | break; |
mjr | 78:1e00b3fa11af | 2891 | } |
mjr | 77:0b96f6867312 | 2892 | |
mjr | 78:1e00b3fa11af | 2893 | // If we ended in state 3, we've successfully decoded |
mjr | 78:1e00b3fa11af | 2894 | // the transmission. Report the decoded data and terminate |
mjr | 78:1e00b3fa11af | 2895 | // learning mode. |
mjr | 78:1e00b3fa11af | 2896 | if (IRLearningMode == 3) |
mjr | 77:0b96f6867312 | 2897 | { |
mjr | 78:1e00b3fa11af | 2898 | // figure the flags: |
mjr | 78:1e00b3fa11af | 2899 | // 0x02 -> dittos |
mjr | 78:1e00b3fa11af | 2900 | uint8_t flags = 0; |
mjr | 78:1e00b3fa11af | 2901 | if (learnedIRCode.hasDittos) |
mjr | 78:1e00b3fa11af | 2902 | flags |= 0x02; |
mjr | 78:1e00b3fa11af | 2903 | |
mjr | 78:1e00b3fa11af | 2904 | // report the code |
mjr | 78:1e00b3fa11af | 2905 | js.reportIRCode(learnedIRCode.proId, flags, learnedIRCode.code); |
mjr | 78:1e00b3fa11af | 2906 | |
mjr | 78:1e00b3fa11af | 2907 | // exit learning mode |
mjr | 78:1e00b3fa11af | 2908 | IRLearningMode = 0; |
mjr | 77:0b96f6867312 | 2909 | } |
mjr | 77:0b96f6867312 | 2910 | } |
mjr | 77:0b96f6867312 | 2911 | |
mjr | 78:1e00b3fa11af | 2912 | // time out of IR learning mode if it's been too long |
mjr | 78:1e00b3fa11af | 2913 | if (IRLearningMode != 0 && IRTimer.read_us() > 10000000L) |
mjr | 77:0b96f6867312 | 2914 | { |
mjr | 78:1e00b3fa11af | 2915 | // report the termination by sending a raw IR report with |
mjr | 78:1e00b3fa11af | 2916 | // zero data elements |
mjr | 78:1e00b3fa11af | 2917 | js.reportRawIR(0, 0); |
mjr | 78:1e00b3fa11af | 2918 | |
mjr | 78:1e00b3fa11af | 2919 | |
mjr | 78:1e00b3fa11af | 2920 | // cancel learning mode |
mjr | 77:0b96f6867312 | 2921 | IRLearningMode = 0; |
mjr | 77:0b96f6867312 | 2922 | } |
mjr | 77:0b96f6867312 | 2923 | } |
mjr | 78:1e00b3fa11af | 2924 | else |
mjr | 77:0b96f6867312 | 2925 | { |
mjr | 78:1e00b3fa11af | 2926 | // Not in learning mode. We don't care about the raw signals; |
mjr | 78:1e00b3fa11af | 2927 | // just run them through the protocol decoders. |
mjr | 78:1e00b3fa11af | 2928 | ir_rx->process(); |
mjr | 78:1e00b3fa11af | 2929 | |
mjr | 78:1e00b3fa11af | 2930 | // Check for decoded commands. Keep going until all commands |
mjr | 78:1e00b3fa11af | 2931 | // have been read. |
mjr | 78:1e00b3fa11af | 2932 | IRCommand c; |
mjr | 78:1e00b3fa11af | 2933 | while (ir_rx->readCommand(c)) |
mjr | 77:0b96f6867312 | 2934 | { |
mjr | 78:1e00b3fa11af | 2935 | // We received a decoded command. Determine if it's a repeat, |
mjr | 78:1e00b3fa11af | 2936 | // and if so, try to determine whether it's an auto-repeat (due |
mjr | 78:1e00b3fa11af | 2937 | // to the remote key being held down) or a distinct new press |
mjr | 78:1e00b3fa11af | 2938 | // on the same key as last time. The distinction is significant |
mjr | 78:1e00b3fa11af | 2939 | // because it affects the auto-repeat behavior of the PC key |
mjr | 78:1e00b3fa11af | 2940 | // input. An auto-repeat represents a key being held down on |
mjr | 78:1e00b3fa11af | 2941 | // the remote, which we want to translate to a (virtual) key |
mjr | 78:1e00b3fa11af | 2942 | // being held down on the PC keyboard; a distinct key press on |
mjr | 78:1e00b3fa11af | 2943 | // the remote translates to a distinct key press on the PC. |
mjr | 78:1e00b3fa11af | 2944 | // |
mjr | 78:1e00b3fa11af | 2945 | // It can only be a repeat if there's a prior command that |
mjr | 78:1e00b3fa11af | 2946 | // hasn't timed out yet, so start by checking for a previous |
mjr | 78:1e00b3fa11af | 2947 | // command. |
mjr | 78:1e00b3fa11af | 2948 | bool repeat = false, autoRepeat = false; |
mjr | 78:1e00b3fa11af | 2949 | if (IRCommandIn != 0) |
mjr | 77:0b96f6867312 | 2950 | { |
mjr | 78:1e00b3fa11af | 2951 | // We have a command in progress. Check to see if the |
mjr | 78:1e00b3fa11af | 2952 | // new command is a repeat of the previous command. Check |
mjr | 78:1e00b3fa11af | 2953 | // first to see if it's a "ditto", which explicitly represents |
mjr | 78:1e00b3fa11af | 2954 | // an auto-repeat of the last command. |
mjr | 78:1e00b3fa11af | 2955 | IRCommandCfg &cmdcfg = cfg.IRCommand[IRCommandIn - 1]; |
mjr | 78:1e00b3fa11af | 2956 | if (c.ditto) |
mjr | 78:1e00b3fa11af | 2957 | { |
mjr | 78:1e00b3fa11af | 2958 | // We received a ditto. Dittos are always auto- |
mjr | 78:1e00b3fa11af | 2959 | // repeats, so it's an auto-repeat as long as the |
mjr | 78:1e00b3fa11af | 2960 | // ditto is in the same protocol as the last command. |
mjr | 78:1e00b3fa11af | 2961 | // If the ditto is in a new protocol, the ditto can't |
mjr | 78:1e00b3fa11af | 2962 | // be for the last command we saw, because a ditto |
mjr | 78:1e00b3fa11af | 2963 | // never changes protocols from its antecedent. In |
mjr | 78:1e00b3fa11af | 2964 | // such a case, we must have missed the antecedent |
mjr | 78:1e00b3fa11af | 2965 | // command and thus don't know what's being repeated. |
mjr | 78:1e00b3fa11af | 2966 | repeat = autoRepeat = (c.proId == cmdcfg.protocol); |
mjr | 78:1e00b3fa11af | 2967 | } |
mjr | 78:1e00b3fa11af | 2968 | else |
mjr | 78:1e00b3fa11af | 2969 | { |
mjr | 78:1e00b3fa11af | 2970 | // It's not a ditto. The new command is a repeat if |
mjr | 78:1e00b3fa11af | 2971 | // it matches the protocol and command code of the |
mjr | 78:1e00b3fa11af | 2972 | // prior command. |
mjr | 78:1e00b3fa11af | 2973 | repeat = (c.proId == cmdcfg.protocol |
mjr | 78:1e00b3fa11af | 2974 | && uint32_t(c.code) == cmdcfg.code.lo |
mjr | 78:1e00b3fa11af | 2975 | && uint32_t(c.code >> 32) == cmdcfg.code.hi); |
mjr | 78:1e00b3fa11af | 2976 | |
mjr | 78:1e00b3fa11af | 2977 | // If the command is a repeat, try to determine whether |
mjr | 78:1e00b3fa11af | 2978 | // it's an auto-repeat or a new press on the same key. |
mjr | 78:1e00b3fa11af | 2979 | // If the protocol uses dittos, it's definitely a new |
mjr | 78:1e00b3fa11af | 2980 | // key press, because an auto-repeat would have used a |
mjr | 78:1e00b3fa11af | 2981 | // ditto. For a protocol that doesn't use dittos, both |
mjr | 78:1e00b3fa11af | 2982 | // an auto-repeat and a new key press just send the key |
mjr | 78:1e00b3fa11af | 2983 | // code again, so we can't tell the difference based on |
mjr | 78:1e00b3fa11af | 2984 | // that alone. But if the protocol has a toggle bit, we |
mjr | 78:1e00b3fa11af | 2985 | // can tell by the toggle bit value: a new key press has |
mjr | 78:1e00b3fa11af | 2986 | // the opposite toggle value as the last key press, while |
mjr | 78:1e00b3fa11af | 2987 | // an auto-repeat has the same toggle. Note that if the |
mjr | 78:1e00b3fa11af | 2988 | // protocol doesn't use toggle bits, the toggle value |
mjr | 78:1e00b3fa11af | 2989 | // will always be the same, so we'll simply always treat |
mjr | 78:1e00b3fa11af | 2990 | // any repeat as an auto-repeat. Many protocols simply |
mjr | 78:1e00b3fa11af | 2991 | // provide no way to distinguish the two, so in such |
mjr | 78:1e00b3fa11af | 2992 | // cases it's consistent with the native implementations |
mjr | 78:1e00b3fa11af | 2993 | // to treat any repeat as an auto-repeat. |
mjr | 78:1e00b3fa11af | 2994 | autoRepeat = |
mjr | 78:1e00b3fa11af | 2995 | repeat |
mjr | 78:1e00b3fa11af | 2996 | && !(cmdcfg.flags & IRFlagDittos) |
mjr | 78:1e00b3fa11af | 2997 | && c.toggle == lastIRToggle; |
mjr | 78:1e00b3fa11af | 2998 | } |
mjr | 78:1e00b3fa11af | 2999 | } |
mjr | 78:1e00b3fa11af | 3000 | |
mjr | 78:1e00b3fa11af | 3001 | // Check to see if it's a repeat of any kind |
mjr | 78:1e00b3fa11af | 3002 | if (repeat) |
mjr | 78:1e00b3fa11af | 3003 | { |
mjr | 78:1e00b3fa11af | 3004 | // It's a repeat. If it's not an auto-repeat, it's a |
mjr | 78:1e00b3fa11af | 3005 | // new distinct key press, so we need to send the PC a |
mjr | 78:1e00b3fa11af | 3006 | // momentary gap where we're not sending the same key, |
mjr | 78:1e00b3fa11af | 3007 | // so that the PC also recognizes this as a distinct |
mjr | 78:1e00b3fa11af | 3008 | // key press event. |
mjr | 78:1e00b3fa11af | 3009 | if (!autoRepeat) |
mjr | 78:1e00b3fa11af | 3010 | IRKeyGap = true; |
mjr | 78:1e00b3fa11af | 3011 | |
mjr | 78:1e00b3fa11af | 3012 | // restart the key-up timer |
mjr | 78:1e00b3fa11af | 3013 | IRTimer.reset(); |
mjr | 78:1e00b3fa11af | 3014 | } |
mjr | 78:1e00b3fa11af | 3015 | else if (c.ditto) |
mjr | 78:1e00b3fa11af | 3016 | { |
mjr | 78:1e00b3fa11af | 3017 | // It's a ditto, but not a repeat of the last command. |
mjr | 78:1e00b3fa11af | 3018 | // But a ditto doesn't contain any information of its own |
mjr | 78:1e00b3fa11af | 3019 | // on the command being repeated, so given that it's not |
mjr | 78:1e00b3fa11af | 3020 | // our last command, we can't infer what command the ditto |
mjr | 78:1e00b3fa11af | 3021 | // is for and thus can't make sense of it. We have to |
mjr | 78:1e00b3fa11af | 3022 | // simply ignore it and wait for the sender to start with |
mjr | 78:1e00b3fa11af | 3023 | // a full command for a new key press. |
mjr | 78:1e00b3fa11af | 3024 | IRCommandIn = 0; |
mjr | 77:0b96f6867312 | 3025 | } |
mjr | 77:0b96f6867312 | 3026 | else |
mjr | 77:0b96f6867312 | 3027 | { |
mjr | 78:1e00b3fa11af | 3028 | // It's not a repeat, so the last command is no longer |
mjr | 78:1e00b3fa11af | 3029 | // in effect (regardless of whether we find a match for |
mjr | 78:1e00b3fa11af | 3030 | // the new command). |
mjr | 78:1e00b3fa11af | 3031 | IRCommandIn = 0; |
mjr | 77:0b96f6867312 | 3032 | |
mjr | 78:1e00b3fa11af | 3033 | // Check to see if we recognize the new command, by |
mjr | 78:1e00b3fa11af | 3034 | // searching for a match in our learned code list. |
mjr | 78:1e00b3fa11af | 3035 | for (int i = 0 ; i < MAX_IR_CODES ; ++i) |
mjr | 77:0b96f6867312 | 3036 | { |
mjr | 78:1e00b3fa11af | 3037 | // if the protocol and command code from the code |
mjr | 78:1e00b3fa11af | 3038 | // list both match the input, it's a match |
mjr | 78:1e00b3fa11af | 3039 | IRCommandCfg &cmdcfg = cfg.IRCommand[i]; |
mjr | 78:1e00b3fa11af | 3040 | if (cmdcfg.protocol == c.proId |
mjr | 78:1e00b3fa11af | 3041 | && cmdcfg.code.lo == uint32_t(c.code) |
mjr | 78:1e00b3fa11af | 3042 | && cmdcfg.code.hi == uint32_t(c.code >> 32)) |
mjr | 78:1e00b3fa11af | 3043 | { |
mjr | 78:1e00b3fa11af | 3044 | // Found it! Make this the last command, and |
mjr | 78:1e00b3fa11af | 3045 | // remember the starting time. |
mjr | 78:1e00b3fa11af | 3046 | IRCommandIn = i + 1; |
mjr | 78:1e00b3fa11af | 3047 | lastIRToggle = c.toggle; |
mjr | 78:1e00b3fa11af | 3048 | IRTimer.reset(); |
mjr | 78:1e00b3fa11af | 3049 | |
mjr | 78:1e00b3fa11af | 3050 | // no need to keep searching |
mjr | 78:1e00b3fa11af | 3051 | break; |
mjr | 78:1e00b3fa11af | 3052 | } |
mjr | 77:0b96f6867312 | 3053 | } |
mjr | 77:0b96f6867312 | 3054 | } |
mjr | 77:0b96f6867312 | 3055 | } |
mjr | 77:0b96f6867312 | 3056 | } |
mjr | 77:0b96f6867312 | 3057 | } |
mjr | 77:0b96f6867312 | 3058 | } |
mjr | 77:0b96f6867312 | 3059 | |
mjr | 74:822a92bc11d2 | 3060 | |
mjr | 11:bd9da7088e6e | 3061 | // --------------------------------------------------------------------------- |
mjr | 11:bd9da7088e6e | 3062 | // |
mjr | 11:bd9da7088e6e | 3063 | // Button input |
mjr | 11:bd9da7088e6e | 3064 | // |
mjr | 11:bd9da7088e6e | 3065 | |
mjr | 18:5e890ebd0023 | 3066 | // button state |
mjr | 18:5e890ebd0023 | 3067 | struct ButtonState |
mjr | 18:5e890ebd0023 | 3068 | { |
mjr | 38:091e511ce8a0 | 3069 | ButtonState() |
mjr | 38:091e511ce8a0 | 3070 | { |
mjr | 53:9b2611964afc | 3071 | physState = logState = prevLogState = 0; |
mjr | 53:9b2611964afc | 3072 | virtState = 0; |
mjr | 53:9b2611964afc | 3073 | dbState = 0; |
mjr | 38:091e511ce8a0 | 3074 | pulseState = 0; |
mjr | 53:9b2611964afc | 3075 | pulseTime = 0; |
mjr | 38:091e511ce8a0 | 3076 | } |
mjr | 35:e959ffba78fd | 3077 | |
mjr | 53:9b2611964afc | 3078 | // "Virtually" press or un-press the button. This can be used to |
mjr | 53:9b2611964afc | 3079 | // control the button state via a software (virtual) source, such as |
mjr | 53:9b2611964afc | 3080 | // the ZB Launch Ball feature. |
mjr | 53:9b2611964afc | 3081 | // |
mjr | 53:9b2611964afc | 3082 | // To allow sharing of one button by multiple virtual sources, each |
mjr | 53:9b2611964afc | 3083 | // virtual source must keep track of its own state internally, and |
mjr | 53:9b2611964afc | 3084 | // only call this routine to CHANGE the state. This is because calls |
mjr | 53:9b2611964afc | 3085 | // to this routine are additive: turning the button ON twice will |
mjr | 53:9b2611964afc | 3086 | // require turning it OFF twice before it actually turns off. |
mjr | 53:9b2611964afc | 3087 | void virtPress(bool on) |
mjr | 53:9b2611964afc | 3088 | { |
mjr | 53:9b2611964afc | 3089 | // Increment or decrement the current state |
mjr | 53:9b2611964afc | 3090 | virtState += on ? 1 : -1; |
mjr | 53:9b2611964afc | 3091 | } |
mjr | 53:9b2611964afc | 3092 | |
mjr | 53:9b2611964afc | 3093 | // DigitalIn for the button, if connected to a physical input |
mjr | 73:4e8ce0b18915 | 3094 | TinyDigitalIn di; |
mjr | 38:091e511ce8a0 | 3095 | |
mjr | 65:739875521aae | 3096 | // Time of last pulse state transition. |
mjr | 65:739875521aae | 3097 | // |
mjr | 65:739875521aae | 3098 | // Each state change sticks for a minimum period; when the timer expires, |
mjr | 65:739875521aae | 3099 | // if the underlying physical switch is in a different state, we switch |
mjr | 65:739875521aae | 3100 | // to the next state and restart the timer. pulseTime is the time remaining |
mjr | 65:739875521aae | 3101 | // remaining before we can make another state transition, in microseconds. |
mjr | 65:739875521aae | 3102 | // The state transitions require a complete cycle, 1 -> 2 -> 3 -> 4 -> 1...; |
mjr | 65:739875521aae | 3103 | // this guarantees that the parity of the pulse count always matches the |
mjr | 65:739875521aae | 3104 | // current physical switch state when the latter is stable, which makes |
mjr | 65:739875521aae | 3105 | // it impossible to "trick" the host by rapidly toggling the switch state. |
mjr | 65:739875521aae | 3106 | // (On my original Pinscape cabinet, I had a hardware pulse generator |
mjr | 65:739875521aae | 3107 | // for coin door, and that *was* possible to trick by rapid toggling. |
mjr | 65:739875521aae | 3108 | // This software system can't be fooled that way.) |
mjr | 65:739875521aae | 3109 | uint32_t pulseTime; |
mjr | 18:5e890ebd0023 | 3110 | |
mjr | 65:739875521aae | 3111 | // Config key index. This points to the ButtonCfg structure in the |
mjr | 65:739875521aae | 3112 | // configuration that contains the PC key mapping for the button. |
mjr | 65:739875521aae | 3113 | uint8_t cfgIndex; |
mjr | 53:9b2611964afc | 3114 | |
mjr | 53:9b2611964afc | 3115 | // Virtual press state. This is used to simulate pressing the button via |
mjr | 53:9b2611964afc | 3116 | // software inputs rather than physical inputs. To allow one button to be |
mjr | 53:9b2611964afc | 3117 | // controlled by mulitple software sources, each source should keep track |
mjr | 53:9b2611964afc | 3118 | // of its own virtual state for the button independently, and then INCREMENT |
mjr | 53:9b2611964afc | 3119 | // this variable when the source's state transitions from off to on, and |
mjr | 53:9b2611964afc | 3120 | // DECREMENT it when the source's state transitions from on to off. That |
mjr | 53:9b2611964afc | 3121 | // will make the button's pressed state the logical OR of all of the virtual |
mjr | 53:9b2611964afc | 3122 | // and physical source states. |
mjr | 53:9b2611964afc | 3123 | uint8_t virtState; |
mjr | 38:091e511ce8a0 | 3124 | |
mjr | 38:091e511ce8a0 | 3125 | // Debounce history. On each scan, we shift in a 1 bit to the lsb if |
mjr | 38:091e511ce8a0 | 3126 | // the physical key is reporting ON, and shift in a 0 bit if the physical |
mjr | 38:091e511ce8a0 | 3127 | // key is reporting OFF. We consider the key to have a new stable state |
mjr | 38:091e511ce8a0 | 3128 | // if we have N consecutive 0's or 1's in the low N bits (where N is |
mjr | 38:091e511ce8a0 | 3129 | // a parameter that determines how long we wait for transients to settle). |
mjr | 53:9b2611964afc | 3130 | uint8_t dbState; |
mjr | 38:091e511ce8a0 | 3131 | |
mjr | 65:739875521aae | 3132 | // current PHYSICAL on/off state, after debouncing |
mjr | 65:739875521aae | 3133 | uint8_t physState : 1; |
mjr | 65:739875521aae | 3134 | |
mjr | 65:739875521aae | 3135 | // current LOGICAL on/off state as reported to the host. |
mjr | 65:739875521aae | 3136 | uint8_t logState : 1; |
mjr | 65:739875521aae | 3137 | |
mjr | 79:682ae3171a08 | 3138 | // Previous logical on/off state, when keys were last processed for USB |
mjr | 79:682ae3171a08 | 3139 | // reports and local effects. This lets us detect edges (transitions) |
mjr | 79:682ae3171a08 | 3140 | // in the logical state, for effects that are triggered when the state |
mjr | 79:682ae3171a08 | 3141 | // changes rather than merely by the button being on or off. |
mjr | 65:739875521aae | 3142 | uint8_t prevLogState : 1; |
mjr | 65:739875521aae | 3143 | |
mjr | 65:739875521aae | 3144 | // Pulse state |
mjr | 65:739875521aae | 3145 | // |
mjr | 65:739875521aae | 3146 | // A button in pulse mode (selected via the config flags for the button) |
mjr | 65:739875521aae | 3147 | // transmits a brief logical button press and release each time the attached |
mjr | 65:739875521aae | 3148 | // physical switch changes state. This is useful for cases where the host |
mjr | 65:739875521aae | 3149 | // expects a key press for each change in the state of the physical switch. |
mjr | 65:739875521aae | 3150 | // The canonical example is the Coin Door switch in VPinMAME, which requires |
mjr | 65:739875521aae | 3151 | // pressing the END key to toggle the open/closed state. This software design |
mjr | 65:739875521aae | 3152 | // isn't easily implemented in a physical coin door, though; the simplest |
mjr | 65:739875521aae | 3153 | // physical sensor for the coin door state is a switch that's on when the |
mjr | 65:739875521aae | 3154 | // door is open and off when the door is closed (or vice versa, but in either |
mjr | 65:739875521aae | 3155 | // case, the switch state corresponds to the current state of the door at any |
mjr | 65:739875521aae | 3156 | // given time, rather than pulsing on state changes). The "pulse mode" |
mjr | 79:682ae3171a08 | 3157 | // option bridges this gap by generating a toggle key event each time |
mjr | 65:739875521aae | 3158 | // there's a change to the physical switch's state. |
mjr | 38:091e511ce8a0 | 3159 | // |
mjr | 38:091e511ce8a0 | 3160 | // Pulse state: |
mjr | 38:091e511ce8a0 | 3161 | // 0 -> not a pulse switch - logical key state equals physical switch state |
mjr | 38:091e511ce8a0 | 3162 | // 1 -> off |
mjr | 38:091e511ce8a0 | 3163 | // 2 -> transitioning off-on |
mjr | 38:091e511ce8a0 | 3164 | // 3 -> on |
mjr | 38:091e511ce8a0 | 3165 | // 4 -> transitioning on-off |
mjr | 65:739875521aae | 3166 | uint8_t pulseState : 3; // 5 states -> we need 3 bits |
mjr | 65:739875521aae | 3167 | |
mjr | 65:739875521aae | 3168 | } __attribute__((packed)); |
mjr | 65:739875521aae | 3169 | |
mjr | 65:739875521aae | 3170 | ButtonState *buttonState; // live button slots, allocated on startup |
mjr | 65:739875521aae | 3171 | int8_t nButtons; // number of live button slots allocated |
mjr | 65:739875521aae | 3172 | int8_t zblButtonIndex = -1; // index of ZB Launch button slot; -1 if unused |
mjr | 18:5e890ebd0023 | 3173 | |
mjr | 66:2e3583fbd2f4 | 3174 | // Shift button state |
mjr | 66:2e3583fbd2f4 | 3175 | struct |
mjr | 66:2e3583fbd2f4 | 3176 | { |
mjr | 66:2e3583fbd2f4 | 3177 | int8_t index; // buttonState[] index of shift button; -1 if none |
mjr | 78:1e00b3fa11af | 3178 | uint8_t state; // current state, for "Key OR Shift" mode: |
mjr | 66:2e3583fbd2f4 | 3179 | // 0 = not shifted |
mjr | 66:2e3583fbd2f4 | 3180 | // 1 = shift button down, no key pressed yet |
mjr | 66:2e3583fbd2f4 | 3181 | // 2 = shift button down, key pressed |
mjr | 78:1e00b3fa11af | 3182 | // 3 = released, sending pulsed keystroke |
mjr | 78:1e00b3fa11af | 3183 | uint32_t pulseTime; // time remaining in pulsed keystroke (state 3) |
mjr | 66:2e3583fbd2f4 | 3184 | } |
mjr | 66:2e3583fbd2f4 | 3185 | __attribute__((packed)) shiftButton; |
mjr | 38:091e511ce8a0 | 3186 | |
mjr | 38:091e511ce8a0 | 3187 | // Button data |
mjr | 38:091e511ce8a0 | 3188 | uint32_t jsButtons = 0; |
mjr | 38:091e511ce8a0 | 3189 | |
mjr | 38:091e511ce8a0 | 3190 | // Keyboard report state. This tracks the USB keyboard state. We can |
mjr | 38:091e511ce8a0 | 3191 | // report at most 6 simultaneous non-modifier keys here, plus the 8 |
mjr | 38:091e511ce8a0 | 3192 | // modifier keys. |
mjr | 38:091e511ce8a0 | 3193 | struct |
mjr | 38:091e511ce8a0 | 3194 | { |
mjr | 38:091e511ce8a0 | 3195 | bool changed; // flag: changed since last report sent |
mjr | 48:058ace2aed1d | 3196 | uint8_t nkeys; // number of active keys in the list |
mjr | 38:091e511ce8a0 | 3197 | uint8_t data[8]; // key state, in USB report format: byte 0 is the modifier key mask, |
mjr | 38:091e511ce8a0 | 3198 | // byte 1 is reserved, and bytes 2-7 are the currently pressed key codes |
mjr | 38:091e511ce8a0 | 3199 | } kbState = { false, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } }; |
mjr | 38:091e511ce8a0 | 3200 | |
mjr | 38:091e511ce8a0 | 3201 | // Media key state |
mjr | 38:091e511ce8a0 | 3202 | struct |
mjr | 38:091e511ce8a0 | 3203 | { |
mjr | 38:091e511ce8a0 | 3204 | bool changed; // flag: changed since last report sent |
mjr | 38:091e511ce8a0 | 3205 | uint8_t data; // key state byte for USB reports |
mjr | 38:091e511ce8a0 | 3206 | } mediaState = { false, 0 }; |
mjr | 38:091e511ce8a0 | 3207 | |
mjr | 79:682ae3171a08 | 3208 | // button scan interrupt timer |
mjr | 79:682ae3171a08 | 3209 | Timeout scanButtonsTimeout; |
mjr | 38:091e511ce8a0 | 3210 | |
mjr | 38:091e511ce8a0 | 3211 | // Button scan interrupt handler. We call this periodically via |
mjr | 38:091e511ce8a0 | 3212 | // a timer interrupt to scan the physical button states. |
mjr | 38:091e511ce8a0 | 3213 | void scanButtons() |
mjr | 38:091e511ce8a0 | 3214 | { |
mjr | 79:682ae3171a08 | 3215 | // schedule the next interrupt |
mjr | 79:682ae3171a08 | 3216 | scanButtonsTimeout.attach_us(&scanButtons, 1000); |
mjr | 79:682ae3171a08 | 3217 | |
mjr | 38:091e511ce8a0 | 3218 | // scan all button input pins |
mjr | 73:4e8ce0b18915 | 3219 | ButtonState *bs = buttonState, *last = bs + nButtons; |
mjr | 73:4e8ce0b18915 | 3220 | for ( ; bs < last ; ++bs) |
mjr | 38:091e511ce8a0 | 3221 | { |
mjr | 73:4e8ce0b18915 | 3222 | // Shift the new state into the debounce history |
mjr | 73:4e8ce0b18915 | 3223 | uint8_t db = (bs->dbState << 1) | bs->di.read(); |
mjr | 73:4e8ce0b18915 | 3224 | bs->dbState = db; |
mjr | 73:4e8ce0b18915 | 3225 | |
mjr | 73:4e8ce0b18915 | 3226 | // If we have all 0's or 1's in the history for the required |
mjr | 73:4e8ce0b18915 | 3227 | // debounce period, the key state is stable, so apply the new |
mjr | 73:4e8ce0b18915 | 3228 | // physical state. Note that the pins are active low, so the |
mjr | 73:4e8ce0b18915 | 3229 | // new button on/off state is the inverse of the GPIO state. |
mjr | 73:4e8ce0b18915 | 3230 | const uint8_t stable = 0x1F; // 00011111b -> low 5 bits = last 5 readings |
mjr | 73:4e8ce0b18915 | 3231 | db &= stable; |
mjr | 73:4e8ce0b18915 | 3232 | if (db == 0 || db == stable) |
mjr | 73:4e8ce0b18915 | 3233 | bs->physState = !db; |
mjr | 38:091e511ce8a0 | 3234 | } |
mjr | 38:091e511ce8a0 | 3235 | } |
mjr | 38:091e511ce8a0 | 3236 | |
mjr | 38:091e511ce8a0 | 3237 | // Button state transition timer. This is used for pulse buttons, to |
mjr | 38:091e511ce8a0 | 3238 | // control the timing of the logical key presses generated by transitions |
mjr | 38:091e511ce8a0 | 3239 | // in the physical button state. |
mjr | 38:091e511ce8a0 | 3240 | Timer buttonTimer; |
mjr | 12:669df364a565 | 3241 | |
mjr | 65:739875521aae | 3242 | // Count a button during the initial setup scan |
mjr | 72:884207c0aab0 | 3243 | void countButton(uint8_t typ, uint8_t shiftTyp, bool &kbKeys) |
mjr | 65:739875521aae | 3244 | { |
mjr | 65:739875521aae | 3245 | // count it |
mjr | 65:739875521aae | 3246 | ++nButtons; |
mjr | 65:739875521aae | 3247 | |
mjr | 67:c39e66c4e000 | 3248 | // if it's a keyboard key or media key, note that we need a USB |
mjr | 67:c39e66c4e000 | 3249 | // keyboard interface |
mjr | 72:884207c0aab0 | 3250 | if (typ == BtnTypeKey || typ == BtnTypeMedia |
mjr | 72:884207c0aab0 | 3251 | || shiftTyp == BtnTypeKey || shiftTyp == BtnTypeMedia) |
mjr | 65:739875521aae | 3252 | kbKeys = true; |
mjr | 65:739875521aae | 3253 | } |
mjr | 65:739875521aae | 3254 | |
mjr | 11:bd9da7088e6e | 3255 | // initialize the button inputs |
mjr | 35:e959ffba78fd | 3256 | void initButtons(Config &cfg, bool &kbKeys) |
mjr | 11:bd9da7088e6e | 3257 | { |
mjr | 66:2e3583fbd2f4 | 3258 | // presume no shift key |
mjr | 66:2e3583fbd2f4 | 3259 | shiftButton.index = -1; |
mjr | 82:4f6209cb5c33 | 3260 | shiftButton.state = 0; |
mjr | 66:2e3583fbd2f4 | 3261 | |
mjr | 65:739875521aae | 3262 | // Count up how many button slots we'll need to allocate. Start |
mjr | 65:739875521aae | 3263 | // with assigned buttons from the configuration, noting that we |
mjr | 65:739875521aae | 3264 | // only need to create slots for buttons that are actually wired. |
mjr | 65:739875521aae | 3265 | nButtons = 0; |
mjr | 65:739875521aae | 3266 | for (int i = 0 ; i < MAX_BUTTONS ; ++i) |
mjr | 65:739875521aae | 3267 | { |
mjr | 65:739875521aae | 3268 | // it's valid if it's wired to a real input pin |
mjr | 65:739875521aae | 3269 | if (wirePinName(cfg.button[i].pin) != NC) |
mjr | 72:884207c0aab0 | 3270 | countButton(cfg.button[i].typ, cfg.button[i].typ2, kbKeys); |
mjr | 65:739875521aae | 3271 | } |
mjr | 65:739875521aae | 3272 | |
mjr | 65:739875521aae | 3273 | // Count virtual buttons |
mjr | 65:739875521aae | 3274 | |
mjr | 65:739875521aae | 3275 | // ZB Launch |
mjr | 65:739875521aae | 3276 | if (cfg.plunger.zbLaunchBall.port != 0) |
mjr | 65:739875521aae | 3277 | { |
mjr | 65:739875521aae | 3278 | // valid - remember the live button index |
mjr | 65:739875521aae | 3279 | zblButtonIndex = nButtons; |
mjr | 65:739875521aae | 3280 | |
mjr | 65:739875521aae | 3281 | // count it |
mjr | 72:884207c0aab0 | 3282 | countButton(cfg.plunger.zbLaunchBall.keytype, BtnTypeNone, kbKeys); |
mjr | 65:739875521aae | 3283 | } |
mjr | 65:739875521aae | 3284 | |
mjr | 65:739875521aae | 3285 | // Allocate the live button slots |
mjr | 65:739875521aae | 3286 | ButtonState *bs = buttonState = new ButtonState[nButtons]; |
mjr | 65:739875521aae | 3287 | |
mjr | 65:739875521aae | 3288 | // Configure the physical inputs |
mjr | 65:739875521aae | 3289 | for (int i = 0 ; i < MAX_BUTTONS ; ++i) |
mjr | 65:739875521aae | 3290 | { |
mjr | 65:739875521aae | 3291 | PinName pin = wirePinName(cfg.button[i].pin); |
mjr | 65:739875521aae | 3292 | if (pin != NC) |
mjr | 65:739875521aae | 3293 | { |
mjr | 65:739875521aae | 3294 | // point back to the config slot for the keyboard data |
mjr | 65:739875521aae | 3295 | bs->cfgIndex = i; |
mjr | 65:739875521aae | 3296 | |
mjr | 65:739875521aae | 3297 | // set up the GPIO input pin for this button |
mjr | 73:4e8ce0b18915 | 3298 | bs->di.assignPin(pin); |
mjr | 65:739875521aae | 3299 | |
mjr | 65:739875521aae | 3300 | // if it's a pulse mode button, set the initial pulse state to Off |
mjr | 65:739875521aae | 3301 | if (cfg.button[i].flags & BtnFlagPulse) |
mjr | 65:739875521aae | 3302 | bs->pulseState = 1; |
mjr | 65:739875521aae | 3303 | |
mjr | 66:2e3583fbd2f4 | 3304 | // If this is the shift button, note its buttonState[] index. |
mjr | 66:2e3583fbd2f4 | 3305 | // We have to figure the buttonState[] index separately from |
mjr | 66:2e3583fbd2f4 | 3306 | // the config index, because the indices can differ if some |
mjr | 66:2e3583fbd2f4 | 3307 | // config slots are left unused. |
mjr | 78:1e00b3fa11af | 3308 | if (cfg.shiftButton.idx == i+1) |
mjr | 66:2e3583fbd2f4 | 3309 | shiftButton.index = bs - buttonState; |
mjr | 66:2e3583fbd2f4 | 3310 | |
mjr | 65:739875521aae | 3311 | // advance to the next button |
mjr | 65:739875521aae | 3312 | ++bs; |
mjr | 65:739875521aae | 3313 | } |
mjr | 65:739875521aae | 3314 | } |
mjr | 65:739875521aae | 3315 | |
mjr | 53:9b2611964afc | 3316 | // Configure the virtual buttons. These are buttons controlled via |
mjr | 53:9b2611964afc | 3317 | // software triggers rather than physical GPIO inputs. The virtual |
mjr | 53:9b2611964afc | 3318 | // buttons have the same control structures as regular buttons, but |
mjr | 53:9b2611964afc | 3319 | // they get their configuration data from other config variables. |
mjr | 53:9b2611964afc | 3320 | |
mjr | 53:9b2611964afc | 3321 | // ZB Launch Ball button |
mjr | 65:739875521aae | 3322 | if (cfg.plunger.zbLaunchBall.port != 0) |
mjr | 11:bd9da7088e6e | 3323 | { |
mjr | 65:739875521aae | 3324 | // Point back to the config slot for the keyboard data. |
mjr | 66:2e3583fbd2f4 | 3325 | // We use a special extra slot for virtual buttons, |
mjr | 66:2e3583fbd2f4 | 3326 | // so we also need to set up the slot data by copying |
mjr | 66:2e3583fbd2f4 | 3327 | // the ZBL config data to our virtual button slot. |
mjr | 65:739875521aae | 3328 | bs->cfgIndex = ZBL_BUTTON_CFG; |
mjr | 65:739875521aae | 3329 | cfg.button[ZBL_BUTTON_CFG].pin = PINNAME_TO_WIRE(NC); |
mjr | 65:739875521aae | 3330 | cfg.button[ZBL_BUTTON_CFG].typ = cfg.plunger.zbLaunchBall.keytype; |
mjr | 65:739875521aae | 3331 | cfg.button[ZBL_BUTTON_CFG].val = cfg.plunger.zbLaunchBall.keycode; |
mjr | 65:739875521aae | 3332 | |
mjr | 66:2e3583fbd2f4 | 3333 | // advance to the next button |
mjr | 65:739875521aae | 3334 | ++bs; |
mjr | 11:bd9da7088e6e | 3335 | } |
mjr | 12:669df364a565 | 3336 | |
mjr | 38:091e511ce8a0 | 3337 | // start the button scan thread |
mjr | 79:682ae3171a08 | 3338 | scanButtonsTimeout.attach_us(scanButtons, 1000); |
mjr | 38:091e511ce8a0 | 3339 | |
mjr | 38:091e511ce8a0 | 3340 | // start the button state transition timer |
mjr | 12:669df364a565 | 3341 | buttonTimer.start(); |
mjr | 11:bd9da7088e6e | 3342 | } |
mjr | 11:bd9da7088e6e | 3343 | |
mjr | 67:c39e66c4e000 | 3344 | // Media key mapping. This maps from an 8-bit USB media key |
mjr | 67:c39e66c4e000 | 3345 | // code to the corresponding bit in our USB report descriptor. |
mjr | 67:c39e66c4e000 | 3346 | // The USB key code is the index, and the value at the index |
mjr | 67:c39e66c4e000 | 3347 | // is the report descriptor bit. See joystick.cpp for the |
mjr | 67:c39e66c4e000 | 3348 | // media descriptor details. Our currently mapped keys are: |
mjr | 67:c39e66c4e000 | 3349 | // |
mjr | 67:c39e66c4e000 | 3350 | // 0xE2 -> Mute -> 0x01 |
mjr | 67:c39e66c4e000 | 3351 | // 0xE9 -> Volume Up -> 0x02 |
mjr | 67:c39e66c4e000 | 3352 | // 0xEA -> Volume Down -> 0x04 |
mjr | 67:c39e66c4e000 | 3353 | // 0xB5 -> Next Track -> 0x08 |
mjr | 67:c39e66c4e000 | 3354 | // 0xB6 -> Previous Track -> 0x10 |
mjr | 67:c39e66c4e000 | 3355 | // 0xB7 -> Stop -> 0x20 |
mjr | 67:c39e66c4e000 | 3356 | // 0xCD -> Play / Pause -> 0x40 |
mjr | 67:c39e66c4e000 | 3357 | // |
mjr | 67:c39e66c4e000 | 3358 | static const uint8_t mediaKeyMap[] = { |
mjr | 67:c39e66c4e000 | 3359 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00-0F |
mjr | 67:c39e66c4e000 | 3360 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 10-1F |
mjr | 67:c39e66c4e000 | 3361 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20-2F |
mjr | 67:c39e66c4e000 | 3362 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 30-3F |
mjr | 67:c39e66c4e000 | 3363 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40-4F |
mjr | 67:c39e66c4e000 | 3364 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 50-5F |
mjr | 67:c39e66c4e000 | 3365 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60-6F |
mjr | 67:c39e66c4e000 | 3366 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 70-7F |
mjr | 67:c39e66c4e000 | 3367 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 80-8F |
mjr | 67:c39e66c4e000 | 3368 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 90-9F |
mjr | 67:c39e66c4e000 | 3369 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // A0-AF |
mjr | 67:c39e66c4e000 | 3370 | 0, 0, 0, 0, 0, 8, 16, 32, 0, 0, 0, 0, 0, 0, 0, 0, // B0-BF |
mjr | 67:c39e66c4e000 | 3371 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, // C0-CF |
mjr | 67:c39e66c4e000 | 3372 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // D0-DF |
mjr | 67:c39e66c4e000 | 3373 | 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 4, 0, 0, 0, 0, 0, // E0-EF |
mjr | 67:c39e66c4e000 | 3374 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // F0-FF |
mjr | 77:0b96f6867312 | 3375 | }; |
mjr | 77:0b96f6867312 | 3376 | |
mjr | 77:0b96f6867312 | 3377 | // Keyboard key/joystick button state. processButtons() uses this to |
mjr | 77:0b96f6867312 | 3378 | // build the set of key presses to report to the PC based on the logical |
mjr | 77:0b96f6867312 | 3379 | // states of the button iputs. |
mjr | 77:0b96f6867312 | 3380 | struct KeyState |
mjr | 77:0b96f6867312 | 3381 | { |
mjr | 77:0b96f6867312 | 3382 | KeyState() |
mjr | 77:0b96f6867312 | 3383 | { |
mjr | 77:0b96f6867312 | 3384 | // zero all members |
mjr | 77:0b96f6867312 | 3385 | memset(this, 0, sizeof(*this)); |
mjr | 77:0b96f6867312 | 3386 | } |
mjr | 77:0b96f6867312 | 3387 | |
mjr | 77:0b96f6867312 | 3388 | // Keyboard media keys currently pressed. This is a bit vector in |
mjr | 77:0b96f6867312 | 3389 | // the format used in our USB keyboard reports (see USBJoystick.cpp). |
mjr | 77:0b96f6867312 | 3390 | uint8_t mediakeys; |
mjr | 77:0b96f6867312 | 3391 | |
mjr | 77:0b96f6867312 | 3392 | // Keyboard modifier (shift) keys currently pressed. This is a bit |
mjr | 77:0b96f6867312 | 3393 | // vector in the format used in our USB keyboard reports (see |
mjr | 77:0b96f6867312 | 3394 | // USBJoystick.cpp). |
mjr | 77:0b96f6867312 | 3395 | uint8_t modkeys; |
mjr | 77:0b96f6867312 | 3396 | |
mjr | 77:0b96f6867312 | 3397 | // Regular keyboard keys currently pressed. Each element is a USB |
mjr | 77:0b96f6867312 | 3398 | // key code, or 0 for empty slots. Note that the USB report format |
mjr | 77:0b96f6867312 | 3399 | // theoretically allows a flexible size limit, but the Windows KB |
mjr | 77:0b96f6867312 | 3400 | // drivers have a fixed limit of 6 simultaneous keys (and won't |
mjr | 77:0b96f6867312 | 3401 | // accept reports with more), so there's no point in making this |
mjr | 77:0b96f6867312 | 3402 | // flexible; we'll just use the fixed size dictated by Windows. |
mjr | 77:0b96f6867312 | 3403 | uint8_t keys[7]; |
mjr | 77:0b96f6867312 | 3404 | |
mjr | 77:0b96f6867312 | 3405 | // number of valid entries in keys[] array |
mjr | 77:0b96f6867312 | 3406 | int nkeys; |
mjr | 77:0b96f6867312 | 3407 | |
mjr | 77:0b96f6867312 | 3408 | // Joystick buttons pressed, as a bit vector. Bit n (1 << n) |
mjr | 77:0b96f6867312 | 3409 | // represents joystick button n, n in 0..31, with 0 meaning |
mjr | 77:0b96f6867312 | 3410 | // unpressed and 1 meaning pressed. |
mjr | 77:0b96f6867312 | 3411 | uint32_t js; |
mjr | 77:0b96f6867312 | 3412 | |
mjr | 77:0b96f6867312 | 3413 | |
mjr | 77:0b96f6867312 | 3414 | // Add a key press. 'typ' is the button type code (ButtonTypeXxx), |
mjr | 77:0b96f6867312 | 3415 | // and 'val' is the value (the meaning of which varies by type code). |
mjr | 77:0b96f6867312 | 3416 | void addKey(uint8_t typ, uint8_t val) |
mjr | 77:0b96f6867312 | 3417 | { |
mjr | 77:0b96f6867312 | 3418 | // add the key according to the type |
mjr | 77:0b96f6867312 | 3419 | switch (typ) |
mjr | 77:0b96f6867312 | 3420 | { |
mjr | 77:0b96f6867312 | 3421 | case BtnTypeJoystick: |
mjr | 77:0b96f6867312 | 3422 | // joystick button |
mjr | 77:0b96f6867312 | 3423 | js |= (1 << (val - 1)); |
mjr | 77:0b96f6867312 | 3424 | break; |
mjr | 77:0b96f6867312 | 3425 | |
mjr | 77:0b96f6867312 | 3426 | case BtnTypeKey: |
mjr | 77:0b96f6867312 | 3427 | // Keyboard key. The USB keyboard report encodes regular |
mjr | 77:0b96f6867312 | 3428 | // keys and modifier keys separately, so we need to check |
mjr | 77:0b96f6867312 | 3429 | // which type we have. Note that past versions mapped the |
mjr | 77:0b96f6867312 | 3430 | // Keyboard Volume Up, Keyboard Volume Down, and Keyboard |
mjr | 77:0b96f6867312 | 3431 | // Mute keys to the corresponding Media keys. We no longer |
mjr | 77:0b96f6867312 | 3432 | // do this; instead, we have the separate BtnTypeMedia for |
mjr | 77:0b96f6867312 | 3433 | // explicitly using media keys if desired. |
mjr | 77:0b96f6867312 | 3434 | if (val >= 0xE0 && val <= 0xE7) |
mjr | 77:0b96f6867312 | 3435 | { |
mjr | 77:0b96f6867312 | 3436 | // It's a modifier key. These are represented in the USB |
mjr | 77:0b96f6867312 | 3437 | // reports with a bit mask. We arrange the mask bits in |
mjr | 77:0b96f6867312 | 3438 | // the same order as the scan codes, so we can figure the |
mjr | 77:0b96f6867312 | 3439 | // appropriate bit with a simple shift. |
mjr | 77:0b96f6867312 | 3440 | modkeys |= (1 << (val - 0xE0)); |
mjr | 77:0b96f6867312 | 3441 | } |
mjr | 77:0b96f6867312 | 3442 | else |
mjr | 77:0b96f6867312 | 3443 | { |
mjr | 77:0b96f6867312 | 3444 | // It's a regular key. Make sure it's not already in the |
mjr | 77:0b96f6867312 | 3445 | // list, and that the list isn't full. If neither of these |
mjr | 77:0b96f6867312 | 3446 | // apply, add the key to the key array. |
mjr | 77:0b96f6867312 | 3447 | if (nkeys < 7) |
mjr | 77:0b96f6867312 | 3448 | { |
mjr | 77:0b96f6867312 | 3449 | bool found = false; |
mjr | 77:0b96f6867312 | 3450 | for (int i = 0 ; i < nkeys ; ++i) |
mjr | 77:0b96f6867312 | 3451 | { |
mjr | 77:0b96f6867312 | 3452 | if (keys[i] == val) |
mjr | 77:0b96f6867312 | 3453 | { |
mjr | 77:0b96f6867312 | 3454 | found = true; |
mjr | 77:0b96f6867312 | 3455 | break; |
mjr | 77:0b96f6867312 | 3456 | } |
mjr | 77:0b96f6867312 | 3457 | } |
mjr | 77:0b96f6867312 | 3458 | if (!found) |
mjr | 77:0b96f6867312 | 3459 | keys[nkeys++] = val; |
mjr | 77:0b96f6867312 | 3460 | } |
mjr | 77:0b96f6867312 | 3461 | } |
mjr | 77:0b96f6867312 | 3462 | break; |
mjr | 77:0b96f6867312 | 3463 | |
mjr | 77:0b96f6867312 | 3464 | case BtnTypeMedia: |
mjr | 77:0b96f6867312 | 3465 | // Media control key. The media keys are mapped in the USB |
mjr | 77:0b96f6867312 | 3466 | // report to bits, whereas the key codes are specified in the |
mjr | 77:0b96f6867312 | 3467 | // config with their USB usage numbers. E.g., the config val |
mjr | 77:0b96f6867312 | 3468 | // for Media Next Track is 0xB5, but we encode this in the USB |
mjr | 77:0b96f6867312 | 3469 | // report as bit 0x08. The mediaKeyMap[] table translates |
mjr | 77:0b96f6867312 | 3470 | // from the USB usage number to the mask bit. If the key isn't |
mjr | 77:0b96f6867312 | 3471 | // among the subset we support, the mapped bit will be zero, so |
mjr | 77:0b96f6867312 | 3472 | // the "|=" will have no effect and the key will be ignored. |
mjr | 77:0b96f6867312 | 3473 | mediakeys |= mediaKeyMap[val]; |
mjr | 77:0b96f6867312 | 3474 | break; |
mjr | 77:0b96f6867312 | 3475 | } |
mjr | 77:0b96f6867312 | 3476 | } |
mjr | 77:0b96f6867312 | 3477 | }; |
mjr | 67:c39e66c4e000 | 3478 | |
mjr | 67:c39e66c4e000 | 3479 | |
mjr | 38:091e511ce8a0 | 3480 | // Process the button state. This sets up the joystick, keyboard, and |
mjr | 38:091e511ce8a0 | 3481 | // media control descriptors with the current state of keys mapped to |
mjr | 38:091e511ce8a0 | 3482 | // those HID interfaces, and executes the local effects for any keys |
mjr | 38:091e511ce8a0 | 3483 | // mapped to special device functions (e.g., Night Mode). |
mjr | 53:9b2611964afc | 3484 | void processButtons(Config &cfg) |
mjr | 35:e959ffba78fd | 3485 | { |
mjr | 77:0b96f6867312 | 3486 | // key state |
mjr | 77:0b96f6867312 | 3487 | KeyState ks; |
mjr | 38:091e511ce8a0 | 3488 | |
mjr | 38:091e511ce8a0 | 3489 | // calculate the time since the last run |
mjr | 53:9b2611964afc | 3490 | uint32_t dt = buttonTimer.read_us(); |
mjr | 18:5e890ebd0023 | 3491 | buttonTimer.reset(); |
mjr | 66:2e3583fbd2f4 | 3492 | |
mjr | 66:2e3583fbd2f4 | 3493 | // check the shift button state |
mjr | 66:2e3583fbd2f4 | 3494 | if (shiftButton.index != -1) |
mjr | 66:2e3583fbd2f4 | 3495 | { |
mjr | 78:1e00b3fa11af | 3496 | // get the shift button's physical state object |
mjr | 66:2e3583fbd2f4 | 3497 | ButtonState *sbs = &buttonState[shiftButton.index]; |
mjr | 78:1e00b3fa11af | 3498 | |
mjr | 78:1e00b3fa11af | 3499 | // figure what to do based on the shift button mode in the config |
mjr | 78:1e00b3fa11af | 3500 | switch (cfg.shiftButton.mode) |
mjr | 66:2e3583fbd2f4 | 3501 | { |
mjr | 66:2e3583fbd2f4 | 3502 | case 0: |
mjr | 78:1e00b3fa11af | 3503 | default: |
mjr | 78:1e00b3fa11af | 3504 | // "Shift OR Key" mode. The shift button doesn't send its key |
mjr | 78:1e00b3fa11af | 3505 | // immediately when pressed. Instead, we wait to see what |
mjr | 78:1e00b3fa11af | 3506 | // happens while it's down. Check the current cycle state. |
mjr | 78:1e00b3fa11af | 3507 | switch (shiftButton.state) |
mjr | 78:1e00b3fa11af | 3508 | { |
mjr | 78:1e00b3fa11af | 3509 | case 0: |
mjr | 78:1e00b3fa11af | 3510 | // Not shifted. Check if the button is now down: if so, |
mjr | 78:1e00b3fa11af | 3511 | // switch to state 1 (shift button down, no key pressed yet). |
mjr | 78:1e00b3fa11af | 3512 | if (sbs->physState) |
mjr | 78:1e00b3fa11af | 3513 | shiftButton.state = 1; |
mjr | 78:1e00b3fa11af | 3514 | break; |
mjr | 78:1e00b3fa11af | 3515 | |
mjr | 78:1e00b3fa11af | 3516 | case 1: |
mjr | 78:1e00b3fa11af | 3517 | // Shift button down, no key pressed yet. If the button is |
mjr | 78:1e00b3fa11af | 3518 | // now up, it counts as an ordinary button press instead of |
mjr | 78:1e00b3fa11af | 3519 | // a shift button press, since the shift function was never |
mjr | 78:1e00b3fa11af | 3520 | // used. Return to unshifted state and start a timed key |
mjr | 78:1e00b3fa11af | 3521 | // pulse event. |
mjr | 78:1e00b3fa11af | 3522 | if (!sbs->physState) |
mjr | 78:1e00b3fa11af | 3523 | { |
mjr | 78:1e00b3fa11af | 3524 | shiftButton.state = 3; |
mjr | 78:1e00b3fa11af | 3525 | shiftButton.pulseTime = 50000+dt; // 50 ms left on the key pulse |
mjr | 78:1e00b3fa11af | 3526 | } |
mjr | 78:1e00b3fa11af | 3527 | break; |
mjr | 78:1e00b3fa11af | 3528 | |
mjr | 78:1e00b3fa11af | 3529 | case 2: |
mjr | 78:1e00b3fa11af | 3530 | // Shift button down, other key was pressed. If the button is |
mjr | 78:1e00b3fa11af | 3531 | // now up, simply clear the shift state without sending a key |
mjr | 78:1e00b3fa11af | 3532 | // press for the shift button itself to the PC. The shift |
mjr | 78:1e00b3fa11af | 3533 | // function was used, so its ordinary key press function is |
mjr | 78:1e00b3fa11af | 3534 | // suppressed. |
mjr | 78:1e00b3fa11af | 3535 | if (!sbs->physState) |
mjr | 78:1e00b3fa11af | 3536 | shiftButton.state = 0; |
mjr | 78:1e00b3fa11af | 3537 | break; |
mjr | 78:1e00b3fa11af | 3538 | |
mjr | 78:1e00b3fa11af | 3539 | case 3: |
mjr | 78:1e00b3fa11af | 3540 | // Sending pulsed keystroke. Deduct the current time interval |
mjr | 78:1e00b3fa11af | 3541 | // from the remaining pulse timer. End the pulse if the time |
mjr | 78:1e00b3fa11af | 3542 | // has expired. |
mjr | 78:1e00b3fa11af | 3543 | if (shiftButton.pulseTime > dt) |
mjr | 78:1e00b3fa11af | 3544 | shiftButton.pulseTime -= dt; |
mjr | 78:1e00b3fa11af | 3545 | else |
mjr | 78:1e00b3fa11af | 3546 | shiftButton.state = 0; |
mjr | 78:1e00b3fa11af | 3547 | break; |
mjr | 78:1e00b3fa11af | 3548 | } |
mjr | 66:2e3583fbd2f4 | 3549 | break; |
mjr | 66:2e3583fbd2f4 | 3550 | |
mjr | 66:2e3583fbd2f4 | 3551 | case 1: |
mjr | 78:1e00b3fa11af | 3552 | // "Shift AND Key" mode. In this mode, the shift button acts |
mjr | 78:1e00b3fa11af | 3553 | // like any other button and sends its mapped key immediately. |
mjr | 78:1e00b3fa11af | 3554 | // The state cycle in this case simply matches the physical |
mjr | 78:1e00b3fa11af | 3555 | // state: ON -> cycle state 1, OFF -> cycle state 0. |
mjr | 78:1e00b3fa11af | 3556 | shiftButton.state = (sbs->physState ? 1 : 0); |
mjr | 66:2e3583fbd2f4 | 3557 | break; |
mjr | 66:2e3583fbd2f4 | 3558 | } |
mjr | 66:2e3583fbd2f4 | 3559 | } |
mjr | 38:091e511ce8a0 | 3560 | |
mjr | 11:bd9da7088e6e | 3561 | // scan the button list |
mjr | 18:5e890ebd0023 | 3562 | ButtonState *bs = buttonState; |
mjr | 65:739875521aae | 3563 | for (int i = 0 ; i < nButtons ; ++i, ++bs) |
mjr | 11:bd9da7088e6e | 3564 | { |
mjr | 77:0b96f6867312 | 3565 | // get the config entry for the button |
mjr | 77:0b96f6867312 | 3566 | ButtonCfg *bc = &cfg.button[bs->cfgIndex]; |
mjr | 77:0b96f6867312 | 3567 | |
mjr | 66:2e3583fbd2f4 | 3568 | // Check the button type: |
mjr | 66:2e3583fbd2f4 | 3569 | // - shift button |
mjr | 66:2e3583fbd2f4 | 3570 | // - pulsed button |
mjr | 66:2e3583fbd2f4 | 3571 | // - regular button |
mjr | 66:2e3583fbd2f4 | 3572 | if (shiftButton.index == i) |
mjr | 66:2e3583fbd2f4 | 3573 | { |
mjr | 78:1e00b3fa11af | 3574 | // This is the shift button. The logical state handling |
mjr | 78:1e00b3fa11af | 3575 | // depends on the mode. |
mjr | 78:1e00b3fa11af | 3576 | switch (cfg.shiftButton.mode) |
mjr | 66:2e3583fbd2f4 | 3577 | { |
mjr | 78:1e00b3fa11af | 3578 | case 0: |
mjr | 78:1e00b3fa11af | 3579 | default: |
mjr | 78:1e00b3fa11af | 3580 | // "Shift OR Key" mode. The logical state is ON only |
mjr | 78:1e00b3fa11af | 3581 | // during the timed pulse when the key is released, which |
mjr | 78:1e00b3fa11af | 3582 | // is signified by shift button state 3. |
mjr | 78:1e00b3fa11af | 3583 | bs->logState = (shiftButton.state == 3); |
mjr | 78:1e00b3fa11af | 3584 | break; |
mjr | 78:1e00b3fa11af | 3585 | |
mjr | 78:1e00b3fa11af | 3586 | case 1: |
mjr | 78:1e00b3fa11af | 3587 | // "Shif AND Key" mode. The shift button acts like any |
mjr | 78:1e00b3fa11af | 3588 | // other button, so it's logically on when physically on. |
mjr | 78:1e00b3fa11af | 3589 | bs->logState = bs->physState; |
mjr | 78:1e00b3fa11af | 3590 | break; |
mjr | 66:2e3583fbd2f4 | 3591 | } |
mjr | 66:2e3583fbd2f4 | 3592 | } |
mjr | 66:2e3583fbd2f4 | 3593 | else if (bs->pulseState != 0) |
mjr | 18:5e890ebd0023 | 3594 | { |
mjr | 38:091e511ce8a0 | 3595 | // if the timer has expired, check for state changes |
mjr | 53:9b2611964afc | 3596 | if (bs->pulseTime > dt) |
mjr | 18:5e890ebd0023 | 3597 | { |
mjr | 53:9b2611964afc | 3598 | // not expired yet - deduct the last interval |
mjr | 53:9b2611964afc | 3599 | bs->pulseTime -= dt; |
mjr | 53:9b2611964afc | 3600 | } |
mjr | 53:9b2611964afc | 3601 | else |
mjr | 53:9b2611964afc | 3602 | { |
mjr | 53:9b2611964afc | 3603 | // pulse time expired - check for a state change |
mjr | 53:9b2611964afc | 3604 | const uint32_t pulseLength = 200000UL; // 200 milliseconds |
mjr | 38:091e511ce8a0 | 3605 | switch (bs->pulseState) |
mjr | 18:5e890ebd0023 | 3606 | { |
mjr | 38:091e511ce8a0 | 3607 | case 1: |
mjr | 38:091e511ce8a0 | 3608 | // off - if the physical switch is now on, start a button pulse |
mjr | 53:9b2611964afc | 3609 | if (bs->physState) |
mjr | 53:9b2611964afc | 3610 | { |
mjr | 38:091e511ce8a0 | 3611 | bs->pulseTime = pulseLength; |
mjr | 38:091e511ce8a0 | 3612 | bs->pulseState = 2; |
mjr | 53:9b2611964afc | 3613 | bs->logState = 1; |
mjr | 38:091e511ce8a0 | 3614 | } |
mjr | 38:091e511ce8a0 | 3615 | break; |
mjr | 18:5e890ebd0023 | 3616 | |
mjr | 38:091e511ce8a0 | 3617 | case 2: |
mjr | 38:091e511ce8a0 | 3618 | // transitioning off to on - end the pulse, and start a gap |
mjr | 38:091e511ce8a0 | 3619 | // equal to the pulse time so that the host can observe the |
mjr | 38:091e511ce8a0 | 3620 | // change in state in the logical button |
mjr | 38:091e511ce8a0 | 3621 | bs->pulseState = 3; |
mjr | 38:091e511ce8a0 | 3622 | bs->pulseTime = pulseLength; |
mjr | 53:9b2611964afc | 3623 | bs->logState = 0; |
mjr | 38:091e511ce8a0 | 3624 | break; |
mjr | 38:091e511ce8a0 | 3625 | |
mjr | 38:091e511ce8a0 | 3626 | case 3: |
mjr | 38:091e511ce8a0 | 3627 | // on - if the physical switch is now off, start a button pulse |
mjr | 53:9b2611964afc | 3628 | if (!bs->physState) |
mjr | 53:9b2611964afc | 3629 | { |
mjr | 38:091e511ce8a0 | 3630 | bs->pulseTime = pulseLength; |
mjr | 38:091e511ce8a0 | 3631 | bs->pulseState = 4; |
mjr | 53:9b2611964afc | 3632 | bs->logState = 1; |
mjr | 38:091e511ce8a0 | 3633 | } |
mjr | 38:091e511ce8a0 | 3634 | break; |
mjr | 38:091e511ce8a0 | 3635 | |
mjr | 38:091e511ce8a0 | 3636 | case 4: |
mjr | 38:091e511ce8a0 | 3637 | // transitioning on to off - end the pulse, and start a gap |
mjr | 38:091e511ce8a0 | 3638 | bs->pulseState = 1; |
mjr | 38:091e511ce8a0 | 3639 | bs->pulseTime = pulseLength; |
mjr | 53:9b2611964afc | 3640 | bs->logState = 0; |
mjr | 38:091e511ce8a0 | 3641 | break; |
mjr | 18:5e890ebd0023 | 3642 | } |
mjr | 18:5e890ebd0023 | 3643 | } |
mjr | 38:091e511ce8a0 | 3644 | } |
mjr | 38:091e511ce8a0 | 3645 | else |
mjr | 38:091e511ce8a0 | 3646 | { |
mjr | 38:091e511ce8a0 | 3647 | // not a pulse switch - the logical state is the same as the physical state |
mjr | 53:9b2611964afc | 3648 | bs->logState = bs->physState; |
mjr | 38:091e511ce8a0 | 3649 | } |
mjr | 77:0b96f6867312 | 3650 | |
mjr | 77:0b96f6867312 | 3651 | // Determine if we're going to use the shifted version of the |
mjr | 78:1e00b3fa11af | 3652 | // button. We're using the shifted version if... |
mjr | 78:1e00b3fa11af | 3653 | // |
mjr | 78:1e00b3fa11af | 3654 | // - the shift button is down, AND |
mjr | 78:1e00b3fa11af | 3655 | // - this button isn't itself the shift button, AND |
mjr | 78:1e00b3fa11af | 3656 | // - this button has some kind of shifted meaning |
mjr | 77:0b96f6867312 | 3657 | // |
mjr | 78:1e00b3fa11af | 3658 | // A "shifted meaning" means that we have any of the following |
mjr | 78:1e00b3fa11af | 3659 | // assigned to the shifted version of the button: a key assignment, |
mjr | 78:1e00b3fa11af | 3660 | // (in typ2,key2), an IR command (in IRCommand2), or Night mode. |
mjr | 78:1e00b3fa11af | 3661 | // |
mjr | 78:1e00b3fa11af | 3662 | // The test for Night Mode is a bit tricky. The shifted version of |
mjr | 78:1e00b3fa11af | 3663 | // the button is the Night Mode toggle if the button matches the |
mjr | 78:1e00b3fa11af | 3664 | // Night Mode button index, AND its flags are set with "toggle mode |
mjr | 78:1e00b3fa11af | 3665 | // ON" (bit 0x02 is on) and "switch mode OFF" (bit 0x01 is off). |
mjr | 78:1e00b3fa11af | 3666 | // So (button flags) & 0x03 must equal 0x02. |
mjr | 77:0b96f6867312 | 3667 | bool useShift = |
mjr | 77:0b96f6867312 | 3668 | (shiftButton.state != 0 |
mjr | 78:1e00b3fa11af | 3669 | && shiftButton.index != i |
mjr | 77:0b96f6867312 | 3670 | && (bc->typ2 != BtnTypeNone |
mjr | 77:0b96f6867312 | 3671 | || bc->IRCommand2 != 0 |
mjr | 77:0b96f6867312 | 3672 | || (cfg.nightMode.btn == i+1 && (cfg.nightMode.flags & 0x03) == 0x02))); |
mjr | 77:0b96f6867312 | 3673 | |
mjr | 77:0b96f6867312 | 3674 | // If we're using the shift function, and no other button has used |
mjr | 77:0b96f6867312 | 3675 | // the shift function yet (shift state 1: "shift button is down but |
mjr | 77:0b96f6867312 | 3676 | // no one has used the shift function yet"), then we've "consumed" |
mjr | 77:0b96f6867312 | 3677 | // the shift button press (so go to shift state 2: "shift button has |
mjr | 77:0b96f6867312 | 3678 | // been used by some other button press that has a shifted meaning"). |
mjr | 78:1e00b3fa11af | 3679 | if (useShift && shiftButton.state == 1 && bs->logState) |
mjr | 77:0b96f6867312 | 3680 | shiftButton.state = 2; |
mjr | 35:e959ffba78fd | 3681 | |
mjr | 38:091e511ce8a0 | 3682 | // carry out any edge effects from buttons changing states |
mjr | 53:9b2611964afc | 3683 | if (bs->logState != bs->prevLogState) |
mjr | 38:091e511ce8a0 | 3684 | { |
mjr | 77:0b96f6867312 | 3685 | // check to see if this is the Night Mode button |
mjr | 53:9b2611964afc | 3686 | if (cfg.nightMode.btn == i + 1) |
mjr | 35:e959ffba78fd | 3687 | { |
mjr | 77:0b96f6867312 | 3688 | // Check the switch type in the config flags. If flag 0x01 is |
mjr | 77:0b96f6867312 | 3689 | // set, it's a persistent on/off switch, so the night mode |
mjr | 77:0b96f6867312 | 3690 | // state simply tracks the current state of the switch. |
mjr | 77:0b96f6867312 | 3691 | // Otherwise, it's a momentary button, so each button push |
mjr | 77:0b96f6867312 | 3692 | // (i.e., each transition from logical state OFF to ON) toggles |
mjr | 77:0b96f6867312 | 3693 | // the night mode state. |
mjr | 77:0b96f6867312 | 3694 | // |
mjr | 77:0b96f6867312 | 3695 | // Note that the "shift" flag (0x02) has no effect in switch |
mjr | 77:0b96f6867312 | 3696 | // mode. Shifting only works for toggle mode. |
mjr | 82:4f6209cb5c33 | 3697 | if ((cfg.nightMode.flags & 0x01) != 0) |
mjr | 53:9b2611964afc | 3698 | { |
mjr | 77:0b96f6867312 | 3699 | // It's an on/off switch. Night mode simply tracks the |
mjr | 77:0b96f6867312 | 3700 | // current switch state. |
mjr | 53:9b2611964afc | 3701 | setNightMode(bs->logState); |
mjr | 53:9b2611964afc | 3702 | } |
mjr | 82:4f6209cb5c33 | 3703 | else if (bs->logState) |
mjr | 53:9b2611964afc | 3704 | { |
mjr | 77:0b96f6867312 | 3705 | // It's a momentary toggle switch. Toggle the night mode |
mjr | 77:0b96f6867312 | 3706 | // state on each distinct press of the button: that is, |
mjr | 77:0b96f6867312 | 3707 | // whenever the button's logical state transitions from |
mjr | 77:0b96f6867312 | 3708 | // OFF to ON. |
mjr | 66:2e3583fbd2f4 | 3709 | // |
mjr | 77:0b96f6867312 | 3710 | // The "shift" flag (0x02) tells us whether night mode is |
mjr | 77:0b96f6867312 | 3711 | // assigned to the shifted or unshifted version of the |
mjr | 77:0b96f6867312 | 3712 | // button. |
mjr | 77:0b96f6867312 | 3713 | bool pressed; |
mjr | 98:4df3c0f7e707 | 3714 | if (shiftButton.index == i) |
mjr | 98:4df3c0f7e707 | 3715 | { |
mjr | 98:4df3c0f7e707 | 3716 | // This button is both the Shift button AND the Night |
mjr | 98:4df3c0f7e707 | 3717 | // Mode button. This is a special case in that the |
mjr | 98:4df3c0f7e707 | 3718 | // Shift status is irrelevant, because it's obviously |
mjr | 98:4df3c0f7e707 | 3719 | // identical to the Night Mode status. So it doesn't |
mjr | 98:4df3c0f7e707 | 3720 | // matter whether or not the Night Mode button has the |
mjr | 98:4df3c0f7e707 | 3721 | // shifted flags; the raw button state is all that |
mjr | 98:4df3c0f7e707 | 3722 | // counts in this case. |
mjr | 98:4df3c0f7e707 | 3723 | pressed = true; |
mjr | 98:4df3c0f7e707 | 3724 | } |
mjr | 98:4df3c0f7e707 | 3725 | else if ((cfg.nightMode.flags & 0x02) != 0) |
mjr | 66:2e3583fbd2f4 | 3726 | { |
mjr | 77:0b96f6867312 | 3727 | // Shift bit is set - night mode is assigned to the |
mjr | 77:0b96f6867312 | 3728 | // shifted version of the button. This is a Night |
mjr | 77:0b96f6867312 | 3729 | // Mode toggle only if the Shift button is pressed. |
mjr | 77:0b96f6867312 | 3730 | pressed = (shiftButton.state != 0); |
mjr | 77:0b96f6867312 | 3731 | } |
mjr | 77:0b96f6867312 | 3732 | else |
mjr | 77:0b96f6867312 | 3733 | { |
mjr | 77:0b96f6867312 | 3734 | // No shift bit - night mode is assigned to the |
mjr | 77:0b96f6867312 | 3735 | // regular unshifted button. The button press only |
mjr | 77:0b96f6867312 | 3736 | // applies if the Shift button is NOT pressed. |
mjr | 77:0b96f6867312 | 3737 | pressed = (shiftButton.state == 0); |
mjr | 66:2e3583fbd2f4 | 3738 | } |
mjr | 66:2e3583fbd2f4 | 3739 | |
mjr | 66:2e3583fbd2f4 | 3740 | // if it's pressed (even after considering the shift mode), |
mjr | 66:2e3583fbd2f4 | 3741 | // toggle night mode |
mjr | 66:2e3583fbd2f4 | 3742 | if (pressed) |
mjr | 53:9b2611964afc | 3743 | toggleNightMode(); |
mjr | 53:9b2611964afc | 3744 | } |
mjr | 35:e959ffba78fd | 3745 | } |
mjr | 38:091e511ce8a0 | 3746 | |
mjr | 77:0b96f6867312 | 3747 | // press or release IR virtual keys on key state changes |
mjr | 77:0b96f6867312 | 3748 | uint8_t irc = useShift ? bc->IRCommand2 : bc->IRCommand; |
mjr | 77:0b96f6867312 | 3749 | if (irc != 0) |
mjr | 77:0b96f6867312 | 3750 | IR_buttonChange(irc, bs->logState); |
mjr | 77:0b96f6867312 | 3751 | |
mjr | 38:091e511ce8a0 | 3752 | // remember the new state for comparison on the next run |
mjr | 53:9b2611964afc | 3753 | bs->prevLogState = bs->logState; |
mjr | 38:091e511ce8a0 | 3754 | } |
mjr | 38:091e511ce8a0 | 3755 | |
mjr | 53:9b2611964afc | 3756 | // if it's pressed, physically or virtually, add it to the appropriate |
mjr | 53:9b2611964afc | 3757 | // key state list |
mjr | 53:9b2611964afc | 3758 | if (bs->logState || bs->virtState) |
mjr | 38:091e511ce8a0 | 3759 | { |
mjr | 70:9f58735a1732 | 3760 | // Get the key type and code. Start by assuming that we're |
mjr | 70:9f58735a1732 | 3761 | // going to use the normal unshifted meaning. |
mjr | 77:0b96f6867312 | 3762 | uint8_t typ, val; |
mjr | 77:0b96f6867312 | 3763 | if (useShift) |
mjr | 66:2e3583fbd2f4 | 3764 | { |
mjr | 77:0b96f6867312 | 3765 | typ = bc->typ2; |
mjr | 77:0b96f6867312 | 3766 | val = bc->val2; |
mjr | 66:2e3583fbd2f4 | 3767 | } |
mjr | 77:0b96f6867312 | 3768 | else |
mjr | 77:0b96f6867312 | 3769 | { |
mjr | 77:0b96f6867312 | 3770 | typ = bc->typ; |
mjr | 77:0b96f6867312 | 3771 | val = bc->val; |
mjr | 77:0b96f6867312 | 3772 | } |
mjr | 77:0b96f6867312 | 3773 | |
mjr | 70:9f58735a1732 | 3774 | // We've decided on the meaning of the button, so process |
mjr | 70:9f58735a1732 | 3775 | // the keyboard or joystick event. |
mjr | 77:0b96f6867312 | 3776 | ks.addKey(typ, val); |
mjr | 18:5e890ebd0023 | 3777 | } |
mjr | 11:bd9da7088e6e | 3778 | } |
mjr | 77:0b96f6867312 | 3779 | |
mjr | 77:0b96f6867312 | 3780 | // If an IR input command is in effect, add the IR command's |
mjr | 77:0b96f6867312 | 3781 | // assigned key, if any. If we're in an IR key gap, don't include |
mjr | 77:0b96f6867312 | 3782 | // the IR key. |
mjr | 77:0b96f6867312 | 3783 | if (IRCommandIn != 0 && !IRKeyGap) |
mjr | 77:0b96f6867312 | 3784 | { |
mjr | 77:0b96f6867312 | 3785 | IRCommandCfg &irc = cfg.IRCommand[IRCommandIn - 1]; |
mjr | 77:0b96f6867312 | 3786 | ks.addKey(irc.keytype, irc.keycode); |
mjr | 77:0b96f6867312 | 3787 | } |
mjr | 77:0b96f6867312 | 3788 | |
mjr | 77:0b96f6867312 | 3789 | // We're finished building the new key state. Update the global |
mjr | 77:0b96f6867312 | 3790 | // key state variables to reflect the new state. |
mjr | 77:0b96f6867312 | 3791 | |
mjr | 77:0b96f6867312 | 3792 | // set the new joystick buttons (no need to check for changes, as we |
mjr | 77:0b96f6867312 | 3793 | // report these on every joystick report whether they changed or not) |
mjr | 77:0b96f6867312 | 3794 | jsButtons = ks.js; |
mjr | 77:0b96f6867312 | 3795 | |
mjr | 77:0b96f6867312 | 3796 | // check for keyboard key changes (we only send keyboard reports when |
mjr | 77:0b96f6867312 | 3797 | // something changes) |
mjr | 77:0b96f6867312 | 3798 | if (kbState.data[0] != ks.modkeys |
mjr | 77:0b96f6867312 | 3799 | || kbState.nkeys != ks.nkeys |
mjr | 77:0b96f6867312 | 3800 | || memcmp(ks.keys, &kbState.data[2], 6) != 0) |
mjr | 35:e959ffba78fd | 3801 | { |
mjr | 35:e959ffba78fd | 3802 | // we have changes - set the change flag and store the new key data |
mjr | 35:e959ffba78fd | 3803 | kbState.changed = true; |
mjr | 77:0b96f6867312 | 3804 | kbState.data[0] = ks.modkeys; |
mjr | 77:0b96f6867312 | 3805 | if (ks.nkeys <= 6) { |
mjr | 35:e959ffba78fd | 3806 | // 6 or fewer simultaneous keys - report the key codes |
mjr | 77:0b96f6867312 | 3807 | kbState.nkeys = ks.nkeys; |
mjr | 77:0b96f6867312 | 3808 | memcpy(&kbState.data[2], ks.keys, 6); |
mjr | 35:e959ffba78fd | 3809 | } |
mjr | 35:e959ffba78fd | 3810 | else { |
mjr | 35:e959ffba78fd | 3811 | // more than 6 simultaneous keys - report rollover (all '1' key codes) |
mjr | 35:e959ffba78fd | 3812 | kbState.nkeys = 6; |
mjr | 35:e959ffba78fd | 3813 | memset(&kbState.data[2], 1, 6); |
mjr | 35:e959ffba78fd | 3814 | } |
mjr | 35:e959ffba78fd | 3815 | } |
mjr | 35:e959ffba78fd | 3816 | |
mjr | 77:0b96f6867312 | 3817 | // check for media key changes (we only send media key reports when |
mjr | 77:0b96f6867312 | 3818 | // something changes) |
mjr | 77:0b96f6867312 | 3819 | if (mediaState.data != ks.mediakeys) |
mjr | 35:e959ffba78fd | 3820 | { |
mjr | 77:0b96f6867312 | 3821 | // we have changes - set the change flag and store the new key data |
mjr | 35:e959ffba78fd | 3822 | mediaState.changed = true; |
mjr | 77:0b96f6867312 | 3823 | mediaState.data = ks.mediakeys; |
mjr | 35:e959ffba78fd | 3824 | } |
mjr | 11:bd9da7088e6e | 3825 | } |
mjr | 11:bd9da7088e6e | 3826 | |
mjr | 73:4e8ce0b18915 | 3827 | // Send a button status report |
mjr | 73:4e8ce0b18915 | 3828 | void reportButtonStatus(USBJoystick &js) |
mjr | 73:4e8ce0b18915 | 3829 | { |
mjr | 73:4e8ce0b18915 | 3830 | // start with all buttons off |
mjr | 73:4e8ce0b18915 | 3831 | uint8_t state[(MAX_BUTTONS+7)/8]; |
mjr | 73:4e8ce0b18915 | 3832 | memset(state, 0, sizeof(state)); |
mjr | 73:4e8ce0b18915 | 3833 | |
mjr | 73:4e8ce0b18915 | 3834 | // pack the button states into bytes, one bit per button |
mjr | 73:4e8ce0b18915 | 3835 | ButtonState *bs = buttonState; |
mjr | 73:4e8ce0b18915 | 3836 | for (int i = 0 ; i < nButtons ; ++i, ++bs) |
mjr | 73:4e8ce0b18915 | 3837 | { |
mjr | 73:4e8ce0b18915 | 3838 | // get the physical state |
mjr | 73:4e8ce0b18915 | 3839 | int b = bs->physState; |
mjr | 73:4e8ce0b18915 | 3840 | |
mjr | 73:4e8ce0b18915 | 3841 | // pack it into the appropriate bit |
mjr | 73:4e8ce0b18915 | 3842 | int idx = bs->cfgIndex; |
mjr | 73:4e8ce0b18915 | 3843 | int si = idx / 8; |
mjr | 73:4e8ce0b18915 | 3844 | int shift = idx & 0x07; |
mjr | 73:4e8ce0b18915 | 3845 | state[si] |= b << shift; |
mjr | 73:4e8ce0b18915 | 3846 | } |
mjr | 73:4e8ce0b18915 | 3847 | |
mjr | 73:4e8ce0b18915 | 3848 | // send the report |
mjr | 73:4e8ce0b18915 | 3849 | js.reportButtonStatus(MAX_BUTTONS, state); |
mjr | 73:4e8ce0b18915 | 3850 | } |
mjr | 73:4e8ce0b18915 | 3851 | |
mjr | 5:a70c0bce770d | 3852 | // --------------------------------------------------------------------------- |
mjr | 5:a70c0bce770d | 3853 | // |
mjr | 5:a70c0bce770d | 3854 | // Customization joystick subbclass |
mjr | 5:a70c0bce770d | 3855 | // |
mjr | 5:a70c0bce770d | 3856 | |
mjr | 5:a70c0bce770d | 3857 | class MyUSBJoystick: public USBJoystick |
mjr | 5:a70c0bce770d | 3858 | { |
mjr | 5:a70c0bce770d | 3859 | public: |
mjr | 35:e959ffba78fd | 3860 | MyUSBJoystick(uint16_t vendor_id, uint16_t product_id, uint16_t product_release, |
mjr | 90:aa4e571da8e8 | 3861 | bool waitForConnect, bool enableJoystick, int axisFormat, bool useKB) |
mjr | 90:aa4e571da8e8 | 3862 | : USBJoystick(vendor_id, product_id, product_release, waitForConnect, enableJoystick, axisFormat, useKB) |
mjr | 5:a70c0bce770d | 3863 | { |
mjr | 54:fd77a6b2f76c | 3864 | sleeping_ = false; |
mjr | 54:fd77a6b2f76c | 3865 | reconnectPending_ = false; |
mjr | 54:fd77a6b2f76c | 3866 | timer_.start(); |
mjr | 54:fd77a6b2f76c | 3867 | } |
mjr | 54:fd77a6b2f76c | 3868 | |
mjr | 54:fd77a6b2f76c | 3869 | // show diagnostic LED feedback for connect state |
mjr | 54:fd77a6b2f76c | 3870 | void diagFlash() |
mjr | 54:fd77a6b2f76c | 3871 | { |
mjr | 54:fd77a6b2f76c | 3872 | if (!configured() || sleeping_) |
mjr | 54:fd77a6b2f76c | 3873 | { |
mjr | 54:fd77a6b2f76c | 3874 | // flash once if sleeping or twice if disconnected |
mjr | 54:fd77a6b2f76c | 3875 | for (int j = isConnected() ? 1 : 2 ; j > 0 ; --j) |
mjr | 54:fd77a6b2f76c | 3876 | { |
mjr | 54:fd77a6b2f76c | 3877 | // short red flash |
mjr | 54:fd77a6b2f76c | 3878 | diagLED(1, 0, 0); |
mjr | 54:fd77a6b2f76c | 3879 | wait_us(50000); |
mjr | 54:fd77a6b2f76c | 3880 | diagLED(0, 0, 0); |
mjr | 54:fd77a6b2f76c | 3881 | wait_us(50000); |
mjr | 54:fd77a6b2f76c | 3882 | } |
mjr | 54:fd77a6b2f76c | 3883 | } |
mjr | 5:a70c0bce770d | 3884 | } |
mjr | 5:a70c0bce770d | 3885 | |
mjr | 5:a70c0bce770d | 3886 | // are we connected? |
mjr | 5:a70c0bce770d | 3887 | int isConnected() { return configured(); } |
mjr | 5:a70c0bce770d | 3888 | |
mjr | 54:fd77a6b2f76c | 3889 | // Are we in sleep mode? If true, this means that the hardware has |
mjr | 54:fd77a6b2f76c | 3890 | // detected no activity on the bus for 3ms. This happens when the |
mjr | 54:fd77a6b2f76c | 3891 | // cable is physically disconnected, the computer is turned off, or |
mjr | 54:fd77a6b2f76c | 3892 | // the connection is otherwise disabled. |
mjr | 54:fd77a6b2f76c | 3893 | bool isSleeping() const { return sleeping_; } |
mjr | 54:fd77a6b2f76c | 3894 | |
mjr | 54:fd77a6b2f76c | 3895 | // If necessary, attempt to recover from a broken connection. |
mjr | 54:fd77a6b2f76c | 3896 | // |
mjr | 54:fd77a6b2f76c | 3897 | // This is a hack, to work around an apparent timing bug in the |
mjr | 54:fd77a6b2f76c | 3898 | // KL25Z USB implementation that I haven't been able to solve any |
mjr | 54:fd77a6b2f76c | 3899 | // other way. |
mjr | 54:fd77a6b2f76c | 3900 | // |
mjr | 54:fd77a6b2f76c | 3901 | // The issue: when we have an established connection, and the |
mjr | 54:fd77a6b2f76c | 3902 | // connection is broken by physically unplugging the cable or by |
mjr | 54:fd77a6b2f76c | 3903 | // rebooting the PC, the KL25Z sometimes fails to reconnect when |
mjr | 54:fd77a6b2f76c | 3904 | // the physical connection is re-established. The failure is |
mjr | 54:fd77a6b2f76c | 3905 | // sporadic; I'd guess it happens about 25% of the time, but I |
mjr | 54:fd77a6b2f76c | 3906 | // haven't collected any real statistics on it. |
mjr | 54:fd77a6b2f76c | 3907 | // |
mjr | 54:fd77a6b2f76c | 3908 | // The proximate cause of the failure is a deadlock in the SETUP |
mjr | 54:fd77a6b2f76c | 3909 | // protocol between the host and device that happens around the |
mjr | 54:fd77a6b2f76c | 3910 | // point where the PC is requesting the configuration descriptor. |
mjr | 54:fd77a6b2f76c | 3911 | // The exact point in the protocol where this occurs varies slightly; |
mjr | 54:fd77a6b2f76c | 3912 | // it can occur a message or two before or after the Get Config |
mjr | 54:fd77a6b2f76c | 3913 | // Descriptor packet. No matter where it happens, the nature of |
mjr | 54:fd77a6b2f76c | 3914 | // the deadlock is the same: the PC thinks it sees a STALL on EP0 |
mjr | 54:fd77a6b2f76c | 3915 | // from the device, so it terminates the connection attempt, which |
mjr | 54:fd77a6b2f76c | 3916 | // stops further traffic on the cable. The KL25Z USB hardware sees |
mjr | 54:fd77a6b2f76c | 3917 | // the lack of traffic and triggers a SLEEP interrupt (a misnomer |
mjr | 54:fd77a6b2f76c | 3918 | // for what should have been called a BROKEN CONNECTION interrupt). |
mjr | 54:fd77a6b2f76c | 3919 | // Both sides simply stop talking at this point, so the connection |
mjr | 54:fd77a6b2f76c | 3920 | // is effectively dead. |
mjr | 54:fd77a6b2f76c | 3921 | // |
mjr | 54:fd77a6b2f76c | 3922 | // The strange thing is that, as far as I can tell, the KL25Z isn't |
mjr | 54:fd77a6b2f76c | 3923 | // doing anything to trigger the STALL on its end. Both the PC |
mjr | 54:fd77a6b2f76c | 3924 | // and the KL25Z are happy up until the very point of the failure |
mjr | 54:fd77a6b2f76c | 3925 | // and show no signs of anything wrong in the protocol exchange. |
mjr | 54:fd77a6b2f76c | 3926 | // In fact, every detail of the protocol exchange up to this point |
mjr | 54:fd77a6b2f76c | 3927 | // is identical to every successful exchange that does finish the |
mjr | 54:fd77a6b2f76c | 3928 | // whole setup process successfully, on both the KL25Z and Windows |
mjr | 54:fd77a6b2f76c | 3929 | // sides of the connection. I can't find any point of difference |
mjr | 54:fd77a6b2f76c | 3930 | // between successful and unsuccessful sequences that suggests why |
mjr | 54:fd77a6b2f76c | 3931 | // the fateful message fails. This makes me suspect that whatever |
mjr | 54:fd77a6b2f76c | 3932 | // is going wrong is inside the KL25Z USB hardware module, which |
mjr | 54:fd77a6b2f76c | 3933 | // is a pretty substantial black box - it has a lot of internal |
mjr | 54:fd77a6b2f76c | 3934 | // state that's inaccessible to the software. Further bolstering |
mjr | 54:fd77a6b2f76c | 3935 | // this theory is a little experiment where I found that I could |
mjr | 54:fd77a6b2f76c | 3936 | // reproduce the exact sequence of events of a failed reconnect |
mjr | 54:fd77a6b2f76c | 3937 | // attempt in an *initial* connection, which is otherwise 100% |
mjr | 54:fd77a6b2f76c | 3938 | // reliable, by inserting a little bit of artifical time padding |
mjr | 54:fd77a6b2f76c | 3939 | // (200us per event) into the SETUP interrupt handler. My |
mjr | 54:fd77a6b2f76c | 3940 | // hypothesis is that the STALL event happens because the KL25Z |
mjr | 54:fd77a6b2f76c | 3941 | // USB hardware is too slow to respond to a message. I'm not |
mjr | 54:fd77a6b2f76c | 3942 | // sure why this would only happen after a disconnect and not |
mjr | 54:fd77a6b2f76c | 3943 | // during the initial connection; maybe there's some reset work |
mjr | 54:fd77a6b2f76c | 3944 | // in the hardware that takes a substantial amount of time after |
mjr | 54:fd77a6b2f76c | 3945 | // a disconnect. |
mjr | 54:fd77a6b2f76c | 3946 | // |
mjr | 54:fd77a6b2f76c | 3947 | // The solution: the problem happens during the SETUP exchange, |
mjr | 54:fd77a6b2f76c | 3948 | // after we've been assigned a bus address. It only happens on |
mjr | 54:fd77a6b2f76c | 3949 | // some percentage of connection requests, so if we can simply |
mjr | 54:fd77a6b2f76c | 3950 | // start over when the failure occurs, we'll eventually succeed |
mjr | 54:fd77a6b2f76c | 3951 | // simply because not every attempt fails. The ideal would be |
mjr | 54:fd77a6b2f76c | 3952 | // to get the success rate up to 100%, but I can't figure out how |
mjr | 54:fd77a6b2f76c | 3953 | // to fix the underlying problem, so this is the next best thing. |
mjr | 54:fd77a6b2f76c | 3954 | // |
mjr | 54:fd77a6b2f76c | 3955 | // We can detect when the failure occurs by noticing when a SLEEP |
mjr | 54:fd77a6b2f76c | 3956 | // interrupt happens while we have an assigned bus address. |
mjr | 54:fd77a6b2f76c | 3957 | // |
mjr | 54:fd77a6b2f76c | 3958 | // To start a new connection attempt, we have to make the *host* |
mjr | 54:fd77a6b2f76c | 3959 | // try again. The logical connection is initiated solely by the |
mjr | 54:fd77a6b2f76c | 3960 | // host. Fortunately, it's easy to get the host to initiate the |
mjr | 54:fd77a6b2f76c | 3961 | // process: if we disconnect on the device side, it effectively |
mjr | 54:fd77a6b2f76c | 3962 | // makes the device look to the PC like it's electrically unplugged. |
mjr | 54:fd77a6b2f76c | 3963 | // When we reconnect on the device side, the PC thinks a new device |
mjr | 54:fd77a6b2f76c | 3964 | // has been plugged in and initiates the logical connection setup. |
mjr | 74:822a92bc11d2 | 3965 | // We have to remain disconnected for some minimum interval before |
mjr | 74:822a92bc11d2 | 3966 | // the host notices; the exact minimum is unclear, but 5ms seems |
mjr | 74:822a92bc11d2 | 3967 | // reliable in practice. |
mjr | 54:fd77a6b2f76c | 3968 | // |
mjr | 54:fd77a6b2f76c | 3969 | // Here's the full algorithm: |
mjr | 54:fd77a6b2f76c | 3970 | // |
mjr | 54:fd77a6b2f76c | 3971 | // 1. In the SLEEP interrupt handler, if we have a bus address, |
mjr | 54:fd77a6b2f76c | 3972 | // we disconnect the device. This happens in ISR context, so we |
mjr | 54:fd77a6b2f76c | 3973 | // can't wait around for 5ms. Instead, we simply set a flag noting |
mjr | 54:fd77a6b2f76c | 3974 | // that the connection has been broken, and we note the time and |
mjr | 54:fd77a6b2f76c | 3975 | // return. |
mjr | 54:fd77a6b2f76c | 3976 | // |
mjr | 54:fd77a6b2f76c | 3977 | // 2. In our main loop, whenever we find that we're disconnected, |
mjr | 54:fd77a6b2f76c | 3978 | // we call recoverConnection(). The main loop's job is basically a |
mjr | 54:fd77a6b2f76c | 3979 | // bunch of device polling. We're just one more device to poll, so |
mjr | 54:fd77a6b2f76c | 3980 | // recoverConnection() will be called soon after a disconnect, and |
mjr | 54:fd77a6b2f76c | 3981 | // then will be called in a loop for as long as we're disconnected. |
mjr | 54:fd77a6b2f76c | 3982 | // |
mjr | 54:fd77a6b2f76c | 3983 | // 3. In recoverConnection(), we check the flag we set in the SLEEP |
mjr | 54:fd77a6b2f76c | 3984 | // handler. If set, we wait until 5ms has elapsed from the SLEEP |
mjr | 54:fd77a6b2f76c | 3985 | // event time that we noted, then we'll reconnect and clear the flag. |
mjr | 54:fd77a6b2f76c | 3986 | // This gives us the required 5ms (or longer) delay between the |
mjr | 54:fd77a6b2f76c | 3987 | // disconnect and reconnect, ensuring that the PC will notice and |
mjr | 54:fd77a6b2f76c | 3988 | // will start over with the connection protocol. |
mjr | 54:fd77a6b2f76c | 3989 | // |
mjr | 54:fd77a6b2f76c | 3990 | // 4. The main loop keeps calling recoverConnection() in a loop for |
mjr | 54:fd77a6b2f76c | 3991 | // as long as we're disconnected, so if the new connection attempt |
mjr | 54:fd77a6b2f76c | 3992 | // triggered in step 3 fails, the SLEEP interrupt will happen again, |
mjr | 54:fd77a6b2f76c | 3993 | // we'll disconnect again, the flag will get set again, and |
mjr | 54:fd77a6b2f76c | 3994 | // recoverConnection() will reconnect again after another suitable |
mjr | 54:fd77a6b2f76c | 3995 | // delay. This will repeat until the connection succeeds or hell |
mjr | 54:fd77a6b2f76c | 3996 | // freezes over. |
mjr | 54:fd77a6b2f76c | 3997 | // |
mjr | 54:fd77a6b2f76c | 3998 | // Each disconnect happens immediately when a reconnect attempt |
mjr | 54:fd77a6b2f76c | 3999 | // fails, and an entire successful connection only takes about 25ms, |
mjr | 54:fd77a6b2f76c | 4000 | // so our loop can retry at more than 30 attempts per second. |
mjr | 54:fd77a6b2f76c | 4001 | // In my testing, lost connections almost always reconnect in |
mjr | 54:fd77a6b2f76c | 4002 | // less than second with this code in place. |
mjr | 54:fd77a6b2f76c | 4003 | void recoverConnection() |
mjr | 54:fd77a6b2f76c | 4004 | { |
mjr | 54:fd77a6b2f76c | 4005 | // if a reconnect is pending, reconnect |
mjr | 54:fd77a6b2f76c | 4006 | if (reconnectPending_) |
mjr | 54:fd77a6b2f76c | 4007 | { |
mjr | 54:fd77a6b2f76c | 4008 | // Loop until we reach 5ms after the last sleep event. |
mjr | 54:fd77a6b2f76c | 4009 | for (bool done = false ; !done ; ) |
mjr | 54:fd77a6b2f76c | 4010 | { |
mjr | 54:fd77a6b2f76c | 4011 | // If we've reached the target time, reconnect. Do the |
mjr | 54:fd77a6b2f76c | 4012 | // time check and flag reset atomically, so that we can't |
mjr | 54:fd77a6b2f76c | 4013 | // have another sleep event sneak in after we've verified |
mjr | 54:fd77a6b2f76c | 4014 | // the time. If another event occurs, it has to happen |
mjr | 54:fd77a6b2f76c | 4015 | // before we check, in which case it'll update the time |
mjr | 54:fd77a6b2f76c | 4016 | // before we check it, or after we clear the flag, in |
mjr | 54:fd77a6b2f76c | 4017 | // which case it will reset the flag and we'll do another |
mjr | 54:fd77a6b2f76c | 4018 | // round the next time we call this routine. |
mjr | 54:fd77a6b2f76c | 4019 | __disable_irq(); |
mjr | 54:fd77a6b2f76c | 4020 | if (uint32_t(timer_.read_us() - lastSleepTime_) > 5000) |
mjr | 54:fd77a6b2f76c | 4021 | { |
mjr | 54:fd77a6b2f76c | 4022 | connect(false); |
mjr | 54:fd77a6b2f76c | 4023 | reconnectPending_ = false; |
mjr | 54:fd77a6b2f76c | 4024 | done = true; |
mjr | 54:fd77a6b2f76c | 4025 | } |
mjr | 54:fd77a6b2f76c | 4026 | __enable_irq(); |
mjr | 54:fd77a6b2f76c | 4027 | } |
mjr | 54:fd77a6b2f76c | 4028 | } |
mjr | 54:fd77a6b2f76c | 4029 | } |
mjr | 5:a70c0bce770d | 4030 | |
mjr | 5:a70c0bce770d | 4031 | protected: |
mjr | 54:fd77a6b2f76c | 4032 | // Handle a USB SLEEP interrupt. This interrupt signifies that the |
mjr | 54:fd77a6b2f76c | 4033 | // USB hardware module hasn't seen any token traffic for 3ms, which |
mjr | 54:fd77a6b2f76c | 4034 | // means that we're either physically or logically disconnected. |
mjr | 54:fd77a6b2f76c | 4035 | // |
mjr | 54:fd77a6b2f76c | 4036 | // Important: this runs in ISR context. |
mjr | 54:fd77a6b2f76c | 4037 | // |
mjr | 54:fd77a6b2f76c | 4038 | // Note that this is a specialized sense of "sleep" that's unrelated |
mjr | 54:fd77a6b2f76c | 4039 | // to the similarly named power modes on the PC. This has nothing |
mjr | 54:fd77a6b2f76c | 4040 | // to do with suspend/sleep mode on the PC, and it's not a low-power |
mjr | 54:fd77a6b2f76c | 4041 | // mode on the KL25Z. They really should have called this interrupt |
mjr | 54:fd77a6b2f76c | 4042 | // DISCONNECT or BROKEN CONNECTION.) |
mjr | 54:fd77a6b2f76c | 4043 | virtual void sleepStateChanged(unsigned int sleeping) |
mjr | 54:fd77a6b2f76c | 4044 | { |
mjr | 54:fd77a6b2f76c | 4045 | // note the new state |
mjr | 54:fd77a6b2f76c | 4046 | sleeping_ = sleeping; |
mjr | 54:fd77a6b2f76c | 4047 | |
mjr | 54:fd77a6b2f76c | 4048 | // If we have a non-zero bus address, we have at least a partial |
mjr | 54:fd77a6b2f76c | 4049 | // connection to the host (we've made it at least as far as the |
mjr | 54:fd77a6b2f76c | 4050 | // SETUP stage). Explicitly disconnect, and the pending reconnect |
mjr | 54:fd77a6b2f76c | 4051 | // flag, and remember the time of the sleep event. |
mjr | 54:fd77a6b2f76c | 4052 | if (USB0->ADDR != 0x00) |
mjr | 54:fd77a6b2f76c | 4053 | { |
mjr | 54:fd77a6b2f76c | 4054 | disconnect(); |
mjr | 54:fd77a6b2f76c | 4055 | lastSleepTime_ = timer_.read_us(); |
mjr | 54:fd77a6b2f76c | 4056 | reconnectPending_ = true; |
mjr | 54:fd77a6b2f76c | 4057 | } |
mjr | 54:fd77a6b2f76c | 4058 | } |
mjr | 54:fd77a6b2f76c | 4059 | |
mjr | 54:fd77a6b2f76c | 4060 | // is the USB connection asleep? |
mjr | 54:fd77a6b2f76c | 4061 | volatile bool sleeping_; |
mjr | 54:fd77a6b2f76c | 4062 | |
mjr | 54:fd77a6b2f76c | 4063 | // flag: reconnect pending after sleep event |
mjr | 54:fd77a6b2f76c | 4064 | volatile bool reconnectPending_; |
mjr | 54:fd77a6b2f76c | 4065 | |
mjr | 54:fd77a6b2f76c | 4066 | // time of last sleep event while connected |
mjr | 54:fd77a6b2f76c | 4067 | volatile uint32_t lastSleepTime_; |
mjr | 54:fd77a6b2f76c | 4068 | |
mjr | 54:fd77a6b2f76c | 4069 | // timer to keep track of interval since last sleep event |
mjr | 54:fd77a6b2f76c | 4070 | Timer timer_; |
mjr | 5:a70c0bce770d | 4071 | }; |
mjr | 5:a70c0bce770d | 4072 | |
mjr | 5:a70c0bce770d | 4073 | // --------------------------------------------------------------------------- |
mjr | 5:a70c0bce770d | 4074 | // |
mjr | 5:a70c0bce770d | 4075 | // Accelerometer (MMA8451Q) |
mjr | 5:a70c0bce770d | 4076 | // |
mjr | 5:a70c0bce770d | 4077 | |
mjr | 5:a70c0bce770d | 4078 | // The MMA8451Q is the KL25Z's on-board 3-axis accelerometer. |
mjr | 5:a70c0bce770d | 4079 | // |
mjr | 5:a70c0bce770d | 4080 | // This is a custom wrapper for the library code to interface to the |
mjr | 6:cc35eb643e8f | 4081 | // MMA8451Q. This class encapsulates an interrupt handler and |
mjr | 6:cc35eb643e8f | 4082 | // automatic calibration. |
mjr | 5:a70c0bce770d | 4083 | // |
mjr | 77:0b96f6867312 | 4084 | // We collect data at the device's maximum rate of 800kHz (one sample |
mjr | 77:0b96f6867312 | 4085 | // every 1.25ms). To keep up with the high data rate, we use the |
mjr | 77:0b96f6867312 | 4086 | // device's internal FIFO, and drain the FIFO by polling on each |
mjr | 77:0b96f6867312 | 4087 | // iteration of our main application loop. In the past, we used an |
mjr | 77:0b96f6867312 | 4088 | // interrupt handler to read the device immediately on the arrival of |
mjr | 77:0b96f6867312 | 4089 | // each sample, but this created too much latency for the IR remote |
mjr | 77:0b96f6867312 | 4090 | // receiver, due to the relatively long time it takes to transfer the |
mjr | 77:0b96f6867312 | 4091 | // accelerometer readings via I2C. The device's on-board FIFO can |
mjr | 77:0b96f6867312 | 4092 | // store up to 32 samples, which gives us up to about 40ms between |
mjr | 77:0b96f6867312 | 4093 | // polling iterations before the buffer overflows. Our main loop runs |
mjr | 77:0b96f6867312 | 4094 | // in under 2ms, so we can easily keep the FIFO far from overflowing. |
mjr | 77:0b96f6867312 | 4095 | // |
mjr | 77:0b96f6867312 | 4096 | // The MMA8451Q has three range modes, +/- 2G, 4G, and 8G. The ADC |
mjr | 77:0b96f6867312 | 4097 | // sample is the same bit width (14 bits) in all modes, so the higher |
mjr | 77:0b96f6867312 | 4098 | // dynamic range modes trade physical precision for range. For our |
mjr | 77:0b96f6867312 | 4099 | // purposes, precision is more important than range, so we use the |
mjr | 77:0b96f6867312 | 4100 | // +/-2G mode. Further, our joystick range is calibrated for only |
mjr | 77:0b96f6867312 | 4101 | // +/-1G. This was unintentional on my part; I didn't look at the |
mjr | 77:0b96f6867312 | 4102 | // MMA8451Q library closely enough to realize it was normalizing to |
mjr | 77:0b96f6867312 | 4103 | // actual "G" units, and assumed that it was normalizing to a -1..+1 |
mjr | 77:0b96f6867312 | 4104 | // scale. In practice, a +/-1G scale seems perfectly adequate for |
mjr | 77:0b96f6867312 | 4105 | // virtual pinball use, so I'm sticking with that range for now. But |
mjr | 77:0b96f6867312 | 4106 | // there might be some benefit in renormalizing to a +/-2G range, in |
mjr | 77:0b96f6867312 | 4107 | // that it would allow for higher dynamic range for very hard nudges. |
mjr | 77:0b96f6867312 | 4108 | // Everyone would have to tweak their nudge sensitivity in VP if I |
mjr | 77:0b96f6867312 | 4109 | // made that change, though, so I'm keeping it as is for now; it would |
mjr | 77:0b96f6867312 | 4110 | // be best to make it a config option ("accelerometer high dynamic range") |
mjr | 77:0b96f6867312 | 4111 | // rather than change it across the board. |
mjr | 5:a70c0bce770d | 4112 | // |
mjr | 6:cc35eb643e8f | 4113 | // We automatically calibrate the accelerometer so that it's not |
mjr | 6:cc35eb643e8f | 4114 | // necessary to get it exactly level when installing it, and so |
mjr | 6:cc35eb643e8f | 4115 | // that it's also not necessary to calibrate it manually. There's |
mjr | 6:cc35eb643e8f | 4116 | // lots of experience that tells us that manual calibration is a |
mjr | 6:cc35eb643e8f | 4117 | // terrible solution, mostly because cabinets tend to shift slightly |
mjr | 6:cc35eb643e8f | 4118 | // during use, requiring frequent recalibration. Instead, we |
mjr | 6:cc35eb643e8f | 4119 | // calibrate automatically. We continuously monitor the acceleration |
mjr | 6:cc35eb643e8f | 4120 | // data, watching for periods of constant (or nearly constant) values. |
mjr | 6:cc35eb643e8f | 4121 | // Any time it appears that the machine has been at rest for a while |
mjr | 6:cc35eb643e8f | 4122 | // (about 5 seconds), we'll average the readings during that rest |
mjr | 6:cc35eb643e8f | 4123 | // period and use the result as the level rest position. This is |
mjr | 6:cc35eb643e8f | 4124 | // is ongoing, so we'll quickly find the center point again if the |
mjr | 6:cc35eb643e8f | 4125 | // machine is moved during play (by an especially aggressive bout |
mjr | 6:cc35eb643e8f | 4126 | // of nudging, say). |
mjr | 5:a70c0bce770d | 4127 | // |
mjr | 5:a70c0bce770d | 4128 | |
mjr | 17:ab3cec0c8bf4 | 4129 | // I2C address of the accelerometer (this is a constant of the KL25Z) |
mjr | 17:ab3cec0c8bf4 | 4130 | const int MMA8451_I2C_ADDRESS = (0x1d<<1); |
mjr | 17:ab3cec0c8bf4 | 4131 | |
mjr | 112:8ed709f455c0 | 4132 | // I2C pins for the accelerometer (constant for the KL25Z) |
mjr | 112:8ed709f455c0 | 4133 | #define MMA8451_SDA_PIN PTE25 |
mjr | 112:8ed709f455c0 | 4134 | #define MMA8451_SCL_PIN PTE24 |
mjr | 17:ab3cec0c8bf4 | 4135 | |
mjr | 17:ab3cec0c8bf4 | 4136 | // Digital in pin to use for the accelerometer interrupt. For the KL25Z, |
mjr | 17:ab3cec0c8bf4 | 4137 | // this can be either PTA14 or PTA15, since those are the pins physically |
mjr | 17:ab3cec0c8bf4 | 4138 | // wired on this board to the MMA8451 interrupt controller. |
mjr | 17:ab3cec0c8bf4 | 4139 | #define MMA8451_INT_PIN PTA15 |
mjr | 17:ab3cec0c8bf4 | 4140 | |
mjr | 17:ab3cec0c8bf4 | 4141 | |
mjr | 6:cc35eb643e8f | 4142 | // accelerometer input history item, for gathering calibration data |
mjr | 6:cc35eb643e8f | 4143 | struct AccHist |
mjr | 5:a70c0bce770d | 4144 | { |
mjr | 77:0b96f6867312 | 4145 | AccHist() { x = y = dsq = 0; xtot = ytot = 0; cnt = 0; } |
mjr | 77:0b96f6867312 | 4146 | void set(int x, int y, AccHist *prv) |
mjr | 6:cc35eb643e8f | 4147 | { |
mjr | 6:cc35eb643e8f | 4148 | // save the raw position |
mjr | 6:cc35eb643e8f | 4149 | this->x = x; |
mjr | 6:cc35eb643e8f | 4150 | this->y = y; |
mjr | 77:0b96f6867312 | 4151 | this->dsq = distanceSquared(prv); |
mjr | 6:cc35eb643e8f | 4152 | } |
mjr | 6:cc35eb643e8f | 4153 | |
mjr | 6:cc35eb643e8f | 4154 | // reading for this entry |
mjr | 77:0b96f6867312 | 4155 | int x, y; |
mjr | 77:0b96f6867312 | 4156 | |
mjr | 77:0b96f6867312 | 4157 | // (distance from previous entry) squared |
mjr | 77:0b96f6867312 | 4158 | int dsq; |
mjr | 5:a70c0bce770d | 4159 | |
mjr | 6:cc35eb643e8f | 4160 | // total and count of samples averaged over this period |
mjr | 77:0b96f6867312 | 4161 | int xtot, ytot; |
mjr | 6:cc35eb643e8f | 4162 | int cnt; |
mjr | 6:cc35eb643e8f | 4163 | |
mjr | 77:0b96f6867312 | 4164 | void clearAvg() { xtot = ytot = 0; cnt = 0; } |
mjr | 77:0b96f6867312 | 4165 | void addAvg(int x, int y) { xtot += x; ytot += y; ++cnt; } |
mjr | 77:0b96f6867312 | 4166 | int xAvg() const { return xtot/cnt; } |
mjr | 77:0b96f6867312 | 4167 | int yAvg() const { return ytot/cnt; } |
mjr | 77:0b96f6867312 | 4168 | |
mjr | 77:0b96f6867312 | 4169 | int distanceSquared(AccHist *p) |
mjr | 77:0b96f6867312 | 4170 | { return square(p->x - x) + square(p->y - y); } |
mjr | 5:a70c0bce770d | 4171 | }; |
mjr | 5:a70c0bce770d | 4172 | |
mjr | 5:a70c0bce770d | 4173 | // accelerometer wrapper class |
mjr | 3:3514575d4f86 | 4174 | class Accel |
mjr | 3:3514575d4f86 | 4175 | { |
mjr | 3:3514575d4f86 | 4176 | public: |
mjr | 112:8ed709f455c0 | 4177 | Accel(const Config &cfg) : mma_(MMA8451_SDA_PIN, MMA8451_SCL_PIN, MMA8451_I2C_ADDRESS) |
mjr | 3:3514575d4f86 | 4178 | { |
mjr | 77:0b96f6867312 | 4179 | // remember the range |
mjr | 112:8ed709f455c0 | 4180 | range_ = cfg.accel.range; |
mjr | 78:1e00b3fa11af | 4181 | |
mjr | 78:1e00b3fa11af | 4182 | // set the auto-centering mode |
mjr | 112:8ed709f455c0 | 4183 | setAutoCenterMode(cfg.accel.autoCenterTime); |
mjr | 78:1e00b3fa11af | 4184 | |
mjr | 78:1e00b3fa11af | 4185 | // no manual centering request has been received |
mjr | 78:1e00b3fa11af | 4186 | manualCenterRequest_ = false; |
mjr | 5:a70c0bce770d | 4187 | |
mjr | 5:a70c0bce770d | 4188 | // reset and initialize |
mjr | 5:a70c0bce770d | 4189 | reset(); |
mjr | 5:a70c0bce770d | 4190 | } |
mjr | 5:a70c0bce770d | 4191 | |
mjr | 112:8ed709f455c0 | 4192 | // Do a full reset of the object. This tries to clear the I2C |
mjr | 112:8ed709f455c0 | 4193 | // bus, and then re-creates the Accel object in place, running |
mjr | 112:8ed709f455c0 | 4194 | // through all of the constructors again. This is only a "soft" |
mjr | 112:8ed709f455c0 | 4195 | // reset, since the KL25Z doesn't give us any way to do a power |
mjr | 112:8ed709f455c0 | 4196 | // cycle on the MMA8451Q from software - its power connection is |
mjr | 112:8ed709f455c0 | 4197 | // hardwired to the KL25Z's main board power connection, so the |
mjr | 112:8ed709f455c0 | 4198 | // only way to power cycle the accelerometer is to power cycle |
mjr | 112:8ed709f455c0 | 4199 | // the whole board. |
mjr | 112:8ed709f455c0 | 4200 | // |
mjr | 112:8ed709f455c0 | 4201 | // We use this to try to reset the accelerometer if it stops |
mjr | 112:8ed709f455c0 | 4202 | // sending us new samples. I've received a few reports from |
mjr | 112:8ed709f455c0 | 4203 | // people who say their accelerometers seem to stop working even |
mjr | 112:8ed709f455c0 | 4204 | // though the rest of the firmware is still functioning normally, |
mjr | 112:8ed709f455c0 | 4205 | // which suggests that there's either a problem in the Accel class |
mjr | 112:8ed709f455c0 | 4206 | // itself, or that the MMA8451Q can get into a non-responsive state |
mjr | 112:8ed709f455c0 | 4207 | // under some circumstances. Since the reports have been extremely |
mjr | 112:8ed709f455c0 | 4208 | // rare and isolated, and since I've never myself seen this happen |
mjr | 112:8ed709f455c0 | 4209 | // on any of the multiple KL25Z boards I've tested with (even after |
mjr | 112:8ed709f455c0 | 4210 | // leaving them running for days at a time), my best guess is that |
mjr | 112:8ed709f455c0 | 4211 | // it's actually a fault in the MMA8451Q. The fact that everyone |
mjr | 112:8ed709f455c0 | 4212 | // who's experienced the accelerometer freeze says that the rest of |
mjr | 112:8ed709f455c0 | 4213 | // the firwmare is still working supports this hypothesis - given |
mjr | 112:8ed709f455c0 | 4214 | // that the firmware is single-threaded, it seems unlikely that a |
mjr | 112:8ed709f455c0 | 4215 | // "crash" of some kind in the accelerometer code wouldn't crash |
mjr | 112:8ed709f455c0 | 4216 | // the firmware as a whole. This soft reset code is an attempt to |
mjr | 112:8ed709f455c0 | 4217 | // recover from a scenario where the MMA8451Q hardware is still |
mjr | 112:8ed709f455c0 | 4218 | // functioning properly, but its internal state machine is somehow |
mjr | 112:8ed709f455c0 | 4219 | // out of sync with the host in such a way that it can no longer |
mjr | 112:8ed709f455c0 | 4220 | // send us samples - either its I2C state machine is stuck in the |
mjr | 112:8ed709f455c0 | 4221 | // middle of a transaction, or its sample processing state machine |
mjr | 112:8ed709f455c0 | 4222 | // is no longer taking samples. The soft reset doesn't have any |
mjr | 112:8ed709f455c0 | 4223 | // hope of rebooting the chip if the freeze is due to some kind |
mjr | 112:8ed709f455c0 | 4224 | // of hardware fault, because our only connection to the chip is |
mjr | 112:8ed709f455c0 | 4225 | // the I2C bus, and there's no reason to think its I2C state |
mjr | 112:8ed709f455c0 | 4226 | // machine would even be running in the event of a hardware fault. |
mjr | 112:8ed709f455c0 | 4227 | // Hopefully we can find out which it is by testing this fix on |
mjr | 112:8ed709f455c0 | 4228 | // boards where the problem is known to have occurred, since it |
mjr | 112:8ed709f455c0 | 4229 | // seems to be readily repeatable for the people who experience |
mjr | 112:8ed709f455c0 | 4230 | // it at all. |
mjr | 112:8ed709f455c0 | 4231 | static void softReset(Accel *accel, const Config &config) |
mjr | 112:8ed709f455c0 | 4232 | { |
mjr | 112:8ed709f455c0 | 4233 | // save the current centering position, so that the user |
mjr | 112:8ed709f455c0 | 4234 | // doesn't see a jump across the reset |
mjr | 112:8ed709f455c0 | 4235 | int cx = accel->cx_, cy = accel->cy_; |
mjr | 112:8ed709f455c0 | 4236 | |
mjr | 112:8ed709f455c0 | 4237 | // try to reset the I2C bus, in case that's |
mjr | 112:8ed709f455c0 | 4238 | accel->clear_i2c(); |
mjr | 112:8ed709f455c0 | 4239 | |
mjr | 112:8ed709f455c0 | 4240 | // re-construct the Accel object |
mjr | 112:8ed709f455c0 | 4241 | new (accel) Accel(config); |
mjr | 112:8ed709f455c0 | 4242 | |
mjr | 112:8ed709f455c0 | 4243 | // restore the center point |
mjr | 112:8ed709f455c0 | 4244 | accel->cx_ = cx; |
mjr | 112:8ed709f455c0 | 4245 | accel->cy_ = cy; |
mjr | 112:8ed709f455c0 | 4246 | } |
mjr | 112:8ed709f455c0 | 4247 | |
mjr | 78:1e00b3fa11af | 4248 | // Request manual centering. This applies the trailing average |
mjr | 78:1e00b3fa11af | 4249 | // of recent measurements and applies it as the new center point |
mjr | 78:1e00b3fa11af | 4250 | // as soon as we have enough data. |
mjr | 78:1e00b3fa11af | 4251 | void manualCenterRequest() { manualCenterRequest_ = true; } |
mjr | 78:1e00b3fa11af | 4252 | |
mjr | 78:1e00b3fa11af | 4253 | // set the auto-centering mode |
mjr | 78:1e00b3fa11af | 4254 | void setAutoCenterMode(int mode) |
mjr | 78:1e00b3fa11af | 4255 | { |
mjr | 78:1e00b3fa11af | 4256 | // remember the mode |
mjr | 78:1e00b3fa11af | 4257 | autoCenterMode_ = mode; |
mjr | 78:1e00b3fa11af | 4258 | |
mjr | 78:1e00b3fa11af | 4259 | // Set the time between checks. We check 5 times over the course |
mjr | 78:1e00b3fa11af | 4260 | // of the centering time, so the check interval is 1/5 of the total. |
mjr | 78:1e00b3fa11af | 4261 | if (mode == 0) |
mjr | 78:1e00b3fa11af | 4262 | { |
mjr | 78:1e00b3fa11af | 4263 | // mode 0 is the old default of 5 seconds, so check every 1s |
mjr | 78:1e00b3fa11af | 4264 | autoCenterCheckTime_ = 1000000; |
mjr | 78:1e00b3fa11af | 4265 | } |
mjr | 78:1e00b3fa11af | 4266 | else if (mode <= 60) |
mjr | 78:1e00b3fa11af | 4267 | { |
mjr | 78:1e00b3fa11af | 4268 | // mode 1-60 means reset after 'mode' seconds; the check |
mjr | 78:1e00b3fa11af | 4269 | // interval is 1/5 of this |
mjr | 78:1e00b3fa11af | 4270 | autoCenterCheckTime_ = mode*200000; |
mjr | 78:1e00b3fa11af | 4271 | } |
mjr | 78:1e00b3fa11af | 4272 | else |
mjr | 78:1e00b3fa11af | 4273 | { |
mjr | 78:1e00b3fa11af | 4274 | // Auto-centering is off, but still gather statistics to apply |
mjr | 78:1e00b3fa11af | 4275 | // when we get a manual centering request. The check interval |
mjr | 78:1e00b3fa11af | 4276 | // in this case is 1/5 of the total time for the trailing average |
mjr | 78:1e00b3fa11af | 4277 | // we apply for the manual centering. We want this to be long |
mjr | 78:1e00b3fa11af | 4278 | // enough to smooth out the data, but short enough that it only |
mjr | 78:1e00b3fa11af | 4279 | // includes recent data. |
mjr | 78:1e00b3fa11af | 4280 | autoCenterCheckTime_ = 500000; |
mjr | 78:1e00b3fa11af | 4281 | } |
mjr | 78:1e00b3fa11af | 4282 | } |
mjr | 78:1e00b3fa11af | 4283 | |
mjr | 112:8ed709f455c0 | 4284 | // Clear the I2C bus for the MMA8451Q. This seems necessary some of the time |
mjr | 112:8ed709f455c0 | 4285 | // for reasons that aren't clear to me. Doing a hard power cycle has the same |
mjr | 112:8ed709f455c0 | 4286 | // effect, but when we do a soft reset, the hardware sometimes seems to leave |
mjr | 112:8ed709f455c0 | 4287 | // the MMA's SDA line stuck low. Presumably, the MMA8451Q's internal state |
mjr | 112:8ed709f455c0 | 4288 | // machine is still in the middle of an I2C transaction, and it expects the |
mjr | 112:8ed709f455c0 | 4289 | // host to clock in/out the rest of the bits for the transaction. Forcing a |
mjr | 112:8ed709f455c0 | 4290 | // series of clock pulses through SCL is the standard remedy for this type |
mjr | 112:8ed709f455c0 | 4291 | // of situation, since it should force the state machine to the end of the |
mjr | 112:8ed709f455c0 | 4292 | // I2C state it's stuck in so that it's ready to start a new transaction. |
mjr | 112:8ed709f455c0 | 4293 | // This really shouldn't be necessary, because the mbed library I2C code that |
mjr | 112:8ed709f455c0 | 4294 | // we're using in the MMA8451Q driver appears to do the same thing when it |
mjr | 112:8ed709f455c0 | 4295 | // sets up the I2C pins, but it should at least be harmless. What we really |
mjr | 112:8ed709f455c0 | 4296 | // need is a way to power-cycle the MMA8451Q, but the KL25Z simply isn't |
mjr | 112:8ed709f455c0 | 4297 | // wired to do that from software; the only way is to power-cycle the whole |
mjr | 112:8ed709f455c0 | 4298 | // board. |
mjr | 112:8ed709f455c0 | 4299 | // |
mjr | 112:8ed709f455c0 | 4300 | // If the accelerometer does get stuck, and a software reboot doesn't reset |
mjr | 112:8ed709f455c0 | 4301 | // it, the only workaround is to manually power cycle the whole KL25Z by |
mjr | 112:8ed709f455c0 | 4302 | // unplugging both of its USB connections. |
mjr | 112:8ed709f455c0 | 4303 | // |
mjr | 112:8ed709f455c0 | 4304 | // The entire Accel object must be re-constructed after calling this, |
mjr | 112:8ed709f455c0 | 4305 | // because this reconfigures the I2C SDA/SCL pins as plain digital in/out |
mjr | 112:8ed709f455c0 | 4306 | // pins. They have to be reconfigured as I2C pins again by the I2C |
mjr | 112:8ed709f455c0 | 4307 | // constructor after this is called. |
mjr | 112:8ed709f455c0 | 4308 | static bool clear_i2c() |
mjr | 112:8ed709f455c0 | 4309 | { |
mjr | 112:8ed709f455c0 | 4310 | // set up both pints as input pins |
mjr | 112:8ed709f455c0 | 4311 | DigitalInOut pin_sda(MMA8451_SDA_PIN, PIN_INPUT, PullNone, 1); |
mjr | 112:8ed709f455c0 | 4312 | DigitalInOut pin_scl(MMA8451_SCL_PIN, PIN_INPUT, PullNone, 1); |
mjr | 112:8ed709f455c0 | 4313 | |
mjr | 112:8ed709f455c0 | 4314 | // if SCL is being held low, the bus is locked by another device; |
mjr | 112:8ed709f455c0 | 4315 | // wait a couple of milliseconds and then give up |
mjr | 112:8ed709f455c0 | 4316 | Timer t; |
mjr | 112:8ed709f455c0 | 4317 | t.start(); |
mjr | 112:8ed709f455c0 | 4318 | while (pin_scl == 0 && t.read_us() < 2000) { } |
mjr | 112:8ed709f455c0 | 4319 | if (pin_scl == 0) |
mjr | 112:8ed709f455c0 | 4320 | return false; |
mjr | 112:8ed709f455c0 | 4321 | |
mjr | 112:8ed709f455c0 | 4322 | // if SDA and SCL are both high, the bus is free |
mjr | 112:8ed709f455c0 | 4323 | if (pin_sda == 1) |
mjr | 112:8ed709f455c0 | 4324 | return true; |
mjr | 112:8ed709f455c0 | 4325 | |
mjr | 112:8ed709f455c0 | 4326 | // Send a series of clock pulses to try to knock the device out |
mjr | 112:8ed709f455c0 | 4327 | // of whatever I2C transaction it thinks it's in the middle of. |
mjr | 112:8ed709f455c0 | 4328 | // 9 pulses should be sufficient for a device with byte commands, |
mjr | 112:8ed709f455c0 | 4329 | // but do some extra for good measure, in case it's in some kind |
mjr | 112:8ed709f455c0 | 4330 | // of multi-byte transaction. |
mjr | 112:8ed709f455c0 | 4331 | pin_scl.mode(PullNone); |
mjr | 112:8ed709f455c0 | 4332 | pin_scl.output(); |
mjr | 112:8ed709f455c0 | 4333 | for (int count = 0; count < 35; count++) |
mjr | 112:8ed709f455c0 | 4334 | { |
mjr | 112:8ed709f455c0 | 4335 | pin_scl.mode(PullNone); |
mjr | 112:8ed709f455c0 | 4336 | pin_scl = 0; |
mjr | 112:8ed709f455c0 | 4337 | wait_us(5); |
mjr | 112:8ed709f455c0 | 4338 | pin_scl.mode(PullUp); |
mjr | 112:8ed709f455c0 | 4339 | pin_scl = 1; |
mjr | 112:8ed709f455c0 | 4340 | wait_us(5); |
mjr | 112:8ed709f455c0 | 4341 | } |
mjr | 112:8ed709f455c0 | 4342 | |
mjr | 112:8ed709f455c0 | 4343 | // Send Stop |
mjr | 112:8ed709f455c0 | 4344 | pin_sda.output(); |
mjr | 112:8ed709f455c0 | 4345 | pin_sda = 0; |
mjr | 112:8ed709f455c0 | 4346 | wait_us(5); |
mjr | 112:8ed709f455c0 | 4347 | pin_scl = 1; |
mjr | 112:8ed709f455c0 | 4348 | wait_us(5); |
mjr | 112:8ed709f455c0 | 4349 | pin_sda = 1; |
mjr | 112:8ed709f455c0 | 4350 | wait_us(5); |
mjr | 112:8ed709f455c0 | 4351 | |
mjr | 112:8ed709f455c0 | 4352 | // confirm that both SDA and SCL are now high, indicating that |
mjr | 112:8ed709f455c0 | 4353 | // the bus is free |
mjr | 112:8ed709f455c0 | 4354 | pin_sda.input(); |
mjr | 112:8ed709f455c0 | 4355 | pin_scl.input(); |
mjr | 112:8ed709f455c0 | 4356 | return (pin_scl != 0 && pin_sda != 0); |
mjr | 112:8ed709f455c0 | 4357 | } |
mjr | 112:8ed709f455c0 | 4358 | |
mjr | 5:a70c0bce770d | 4359 | void reset() |
mjr | 5:a70c0bce770d | 4360 | { |
mjr | 6:cc35eb643e8f | 4361 | // clear the center point |
mjr | 77:0b96f6867312 | 4362 | cx_ = cy_ = 0; |
mjr | 6:cc35eb643e8f | 4363 | |
mjr | 77:0b96f6867312 | 4364 | // start the auto-centering timer |
mjr | 5:a70c0bce770d | 4365 | tCenter_.start(); |
mjr | 5:a70c0bce770d | 4366 | iAccPrv_ = nAccPrv_ = 0; |
mjr | 6:cc35eb643e8f | 4367 | |
mjr | 5:a70c0bce770d | 4368 | // reset and initialize the MMA8451Q |
mjr | 5:a70c0bce770d | 4369 | mma_.init(); |
mjr | 77:0b96f6867312 | 4370 | |
mjr | 77:0b96f6867312 | 4371 | // set the range |
mjr | 77:0b96f6867312 | 4372 | mma_.setRange( |
mjr | 77:0b96f6867312 | 4373 | range_ == AccelRange4G ? 4 : |
mjr | 77:0b96f6867312 | 4374 | range_ == AccelRange8G ? 8 : |
mjr | 77:0b96f6867312 | 4375 | 2); |
mjr | 6:cc35eb643e8f | 4376 | |
mjr | 77:0b96f6867312 | 4377 | // set the average accumulators to zero |
mjr | 77:0b96f6867312 | 4378 | xSum_ = ySum_ = 0; |
mjr | 77:0b96f6867312 | 4379 | nSum_ = 0; |
mjr | 3:3514575d4f86 | 4380 | |
mjr | 3:3514575d4f86 | 4381 | // read the current registers to clear the data ready flag |
mjr | 6:cc35eb643e8f | 4382 | mma_.getAccXYZ(ax_, ay_, az_); |
mjr | 112:8ed709f455c0 | 4383 | |
mjr | 112:8ed709f455c0 | 4384 | // start the FIFO timer |
mjr | 112:8ed709f455c0 | 4385 | fifoTimer.reset(); |
mjr | 112:8ed709f455c0 | 4386 | fifoTimer.start(); |
mjr | 112:8ed709f455c0 | 4387 | tLastSample = tLastChangedSample = fifoTimer.read_us(); |
mjr | 3:3514575d4f86 | 4388 | } |
mjr | 3:3514575d4f86 | 4389 | |
mjr | 112:8ed709f455c0 | 4390 | // Poll the accelerometer. Returns true on success, false if the |
mjr | 112:8ed709f455c0 | 4391 | // device appears to be wedged (because we haven't received a unique |
mjr | 112:8ed709f455c0 | 4392 | // sample in a long time). The caller can try re-creating the Accel |
mjr | 112:8ed709f455c0 | 4393 | // object if the device is wedged. |
mjr | 112:8ed709f455c0 | 4394 | bool poll() |
mjr | 76:7f5912b6340e | 4395 | { |
mjr | 77:0b96f6867312 | 4396 | // read samples until we clear the FIFO |
mjr | 77:0b96f6867312 | 4397 | while (mma_.getFIFOCount() != 0) |
mjr | 77:0b96f6867312 | 4398 | { |
mjr | 112:8ed709f455c0 | 4399 | // read the raw data |
mjr | 77:0b96f6867312 | 4400 | int x, y, z; |
mjr | 77:0b96f6867312 | 4401 | mma_.getAccXYZ(x, y, z); |
mjr | 77:0b96f6867312 | 4402 | |
mjr | 112:8ed709f455c0 | 4403 | // note the time |
mjr | 112:8ed709f455c0 | 4404 | tLastSample = fifoTimer.read_us(); |
mjr | 112:8ed709f455c0 | 4405 | |
mjr | 112:8ed709f455c0 | 4406 | // note if this sample differs from the last one, to see if |
mjr | 112:8ed709f455c0 | 4407 | // the accelerometer appears to be stuck |
mjr | 112:8ed709f455c0 | 4408 | if (x != ax_ || y != ay_ || z != az_) |
mjr | 112:8ed709f455c0 | 4409 | tLastChangedSample = tLastSample; |
mjr | 112:8ed709f455c0 | 4410 | |
mjr | 77:0b96f6867312 | 4411 | // add the new reading to the running total for averaging |
mjr | 77:0b96f6867312 | 4412 | xSum_ += (x - cx_); |
mjr | 77:0b96f6867312 | 4413 | ySum_ += (y - cy_); |
mjr | 77:0b96f6867312 | 4414 | ++nSum_; |
mjr | 77:0b96f6867312 | 4415 | |
mjr | 77:0b96f6867312 | 4416 | // store the updates |
mjr | 77:0b96f6867312 | 4417 | ax_ = x; |
mjr | 77:0b96f6867312 | 4418 | ay_ = y; |
mjr | 77:0b96f6867312 | 4419 | az_ = z; |
mjr | 77:0b96f6867312 | 4420 | } |
mjr | 112:8ed709f455c0 | 4421 | |
mjr | 112:8ed709f455c0 | 4422 | // If we haven't seen a new sample in a while, the device |
mjr | 112:8ed709f455c0 | 4423 | // might be stuck. Some people have observed an apparent |
mjr | 112:8ed709f455c0 | 4424 | // freeze in the accelerometer readings even while the |
mjr | 112:8ed709f455c0 | 4425 | // pluger and key inputs continue working, which seems |
mjr | 112:8ed709f455c0 | 4426 | // like it must be due to something stuck on the MMA8451Q. |
mjr | 112:8ed709f455c0 | 4427 | // The caller can try a software reset in that case, by |
mjr | 112:8ed709f455c0 | 4428 | // re-creating the Accel object. That will go through |
mjr | 112:8ed709f455c0 | 4429 | // all of the I2C and MMA8451Q intialization code again |
mjr | 112:8ed709f455c0 | 4430 | // to try to get things back to a good state. |
mjr | 112:8ed709f455c0 | 4431 | // |
mjr | 112:8ed709f455c0 | 4432 | // We poll about every 2.5ms (or more often, depending on |
mjr | 112:8ed709f455c0 | 4433 | // the plunger sensor type), and we have the accelerometer |
mjr | 112:8ed709f455c0 | 4434 | // set to generate samples at 800 Hz = every 1.25ms, so it |
mjr | 112:8ed709f455c0 | 4435 | // would definitely indicate trouble if the last samples |
mjr | 112:8ed709f455c0 | 4436 | // from the device are older than 5ms. As for *unique* |
mjr | 112:8ed709f455c0 | 4437 | // samples, that's a harder call, since it depends on how |
mjr | 112:8ed709f455c0 | 4438 | // much background noise there is. Given the sensitivity |
mjr | 112:8ed709f455c0 | 4439 | // of the device, though, my experience is that nearly |
mjr | 112:8ed709f455c0 | 4440 | // every sample will have at least one bit of difference |
mjr | 112:8ed709f455c0 | 4441 | // from the last, so it's unlikely to see more than a few |
mjr | 112:8ed709f455c0 | 4442 | // identical samples in a row, and extremely unlikely to |
mjr | 112:8ed709f455c0 | 4443 | // see, say, 10 or 20 consecutive identical readings. To |
mjr | 112:8ed709f455c0 | 4444 | // be conservative, we'll time out the existence of a |
mjr | 112:8ed709f455c0 | 4445 | // reading at 100ms, and unique readings at 2s. This |
mjr | 112:8ed709f455c0 | 4446 | // should reset a non-responsive device well before the |
mjr | 112:8ed709f455c0 | 4447 | // freeze becomes apparent to the user (unless they're |
mjr | 112:8ed709f455c0 | 4448 | // deliberately looking for it), but should also ensure |
mjr | 112:8ed709f455c0 | 4449 | // that we don't reset unnecessarily - 2s represents 1600 |
mjr | 112:8ed709f455c0 | 4450 | // consecutive identical samples, and I think the odds of |
mjr | 112:8ed709f455c0 | 4451 | // that happening for real are practically zero, barring |
mjr | 112:8ed709f455c0 | 4452 | // some kind of test bed with extreme vibration suppression. |
mjr | 112:8ed709f455c0 | 4453 | uint32_t tNow = fifoTimer.read_us(); |
mjr | 112:8ed709f455c0 | 4454 | if (static_cast<uint32_t>(tNow - tLastSample) > 100000 // 100 ms |
mjr | 112:8ed709f455c0 | 4455 | || static_cast<uint32_t>(tNow - tLastChangedSample) > 2000000) // 2 seconds |
mjr | 112:8ed709f455c0 | 4456 | { |
mjr | 112:8ed709f455c0 | 4457 | // appears to be wedged |
mjr | 112:8ed709f455c0 | 4458 | return false; |
mjr | 112:8ed709f455c0 | 4459 | } |
mjr | 112:8ed709f455c0 | 4460 | |
mjr | 112:8ed709f455c0 | 4461 | // okay |
mjr | 112:8ed709f455c0 | 4462 | return true; |
mjr | 76:7f5912b6340e | 4463 | } |
mjr | 112:8ed709f455c0 | 4464 | |
mjr | 112:8ed709f455c0 | 4465 | // timer, for monitoring incoming FIFO samples |
mjr | 112:8ed709f455c0 | 4466 | Timer fifoTimer; |
mjr | 112:8ed709f455c0 | 4467 | |
mjr | 112:8ed709f455c0 | 4468 | // time of last sample from FIFO |
mjr | 112:8ed709f455c0 | 4469 | uint32_t tLastSample; |
mjr | 112:8ed709f455c0 | 4470 | |
mjr | 112:8ed709f455c0 | 4471 | // time of last *different* sample from FIFO |
mjr | 112:8ed709f455c0 | 4472 | uint32_t tLastChangedSample; |
mjr | 112:8ed709f455c0 | 4473 | |
mjr | 9:fd65b0a94720 | 4474 | void get(int &x, int &y) |
mjr | 3:3514575d4f86 | 4475 | { |
mjr | 77:0b96f6867312 | 4476 | // read the shared data and store locally for calculations |
mjr | 77:0b96f6867312 | 4477 | int ax = ax_, ay = ay_; |
mjr | 77:0b96f6867312 | 4478 | int xSum = xSum_, ySum = ySum_; |
mjr | 77:0b96f6867312 | 4479 | int nSum = nSum_; |
mjr | 6:cc35eb643e8f | 4480 | |
mjr | 77:0b96f6867312 | 4481 | // reset the average accumulators for the next run |
mjr | 77:0b96f6867312 | 4482 | xSum_ = ySum_ = 0; |
mjr | 77:0b96f6867312 | 4483 | nSum_ = 0; |
mjr | 77:0b96f6867312 | 4484 | |
mjr | 77:0b96f6867312 | 4485 | // add this sample to the current calibration interval's running total |
mjr | 77:0b96f6867312 | 4486 | AccHist *p = accPrv_ + iAccPrv_; |
mjr | 77:0b96f6867312 | 4487 | p->addAvg(ax, ay); |
mjr | 77:0b96f6867312 | 4488 | |
mjr | 78:1e00b3fa11af | 4489 | // If we're in auto-centering mode, check for auto-centering |
mjr | 78:1e00b3fa11af | 4490 | // at intervals of 1/5 of the overall time. If we're not in |
mjr | 78:1e00b3fa11af | 4491 | // auto-centering mode, check anyway at one-second intervals |
mjr | 78:1e00b3fa11af | 4492 | // so that we gather averages for manual centering requests. |
mjr | 78:1e00b3fa11af | 4493 | if (tCenter_.read_us() > autoCenterCheckTime_) |
mjr | 77:0b96f6867312 | 4494 | { |
mjr | 77:0b96f6867312 | 4495 | // add the latest raw sample to the history list |
mjr | 77:0b96f6867312 | 4496 | AccHist *prv = p; |
mjr | 77:0b96f6867312 | 4497 | iAccPrv_ = (iAccPrv_ + 1); |
mjr | 77:0b96f6867312 | 4498 | if (iAccPrv_ >= maxAccPrv) |
mjr | 77:0b96f6867312 | 4499 | iAccPrv_ = 0; |
mjr | 77:0b96f6867312 | 4500 | p = accPrv_ + iAccPrv_; |
mjr | 77:0b96f6867312 | 4501 | p->set(ax, ay, prv); |
mjr | 77:0b96f6867312 | 4502 | |
mjr | 78:1e00b3fa11af | 4503 | // if we have a full complement, check for auto-centering |
mjr | 77:0b96f6867312 | 4504 | if (nAccPrv_ >= maxAccPrv) |
mjr | 77:0b96f6867312 | 4505 | { |
mjr | 78:1e00b3fa11af | 4506 | // Center if: |
mjr | 78:1e00b3fa11af | 4507 | // |
mjr | 78:1e00b3fa11af | 4508 | // - Auto-centering is on, and we've been stable over the |
mjr | 78:1e00b3fa11af | 4509 | // whole sample period at our spot-check points |
mjr | 78:1e00b3fa11af | 4510 | // |
mjr | 78:1e00b3fa11af | 4511 | // - A manual centering request is pending |
mjr | 78:1e00b3fa11af | 4512 | // |
mjr | 77:0b96f6867312 | 4513 | static const int accTol = 164*164; // 1% of range, squared |
mjr | 77:0b96f6867312 | 4514 | AccHist *p0 = accPrv_; |
mjr | 78:1e00b3fa11af | 4515 | if (manualCenterRequest_ |
mjr | 78:1e00b3fa11af | 4516 | || (autoCenterMode_ <= 60 |
mjr | 78:1e00b3fa11af | 4517 | && p0[0].dsq < accTol |
mjr | 78:1e00b3fa11af | 4518 | && p0[1].dsq < accTol |
mjr | 78:1e00b3fa11af | 4519 | && p0[2].dsq < accTol |
mjr | 78:1e00b3fa11af | 4520 | && p0[3].dsq < accTol |
mjr | 78:1e00b3fa11af | 4521 | && p0[4].dsq < accTol)) |
mjr | 77:0b96f6867312 | 4522 | { |
mjr | 77:0b96f6867312 | 4523 | // Figure the new calibration point as the average of |
mjr | 77:0b96f6867312 | 4524 | // the samples over the rest period |
mjr | 77:0b96f6867312 | 4525 | cx_ = (p0[0].xAvg() + p0[1].xAvg() + p0[2].xAvg() + p0[3].xAvg() + p0[4].xAvg())/5; |
mjr | 77:0b96f6867312 | 4526 | cy_ = (p0[0].yAvg() + p0[1].yAvg() + p0[2].yAvg() + p0[3].yAvg() + p0[4].yAvg())/5; |
mjr | 78:1e00b3fa11af | 4527 | |
mjr | 78:1e00b3fa11af | 4528 | // clear any pending manual centering request |
mjr | 78:1e00b3fa11af | 4529 | manualCenterRequest_ = false; |
mjr | 77:0b96f6867312 | 4530 | } |
mjr | 77:0b96f6867312 | 4531 | } |
mjr | 77:0b96f6867312 | 4532 | else |
mjr | 77:0b96f6867312 | 4533 | { |
mjr | 77:0b96f6867312 | 4534 | // not enough samples yet; just up the count |
mjr | 77:0b96f6867312 | 4535 | ++nAccPrv_; |
mjr | 77:0b96f6867312 | 4536 | } |
mjr | 6:cc35eb643e8f | 4537 | |
mjr | 77:0b96f6867312 | 4538 | // clear the new item's running totals |
mjr | 77:0b96f6867312 | 4539 | p->clearAvg(); |
mjr | 5:a70c0bce770d | 4540 | |
mjr | 77:0b96f6867312 | 4541 | // reset the timer |
mjr | 77:0b96f6867312 | 4542 | tCenter_.reset(); |
mjr | 77:0b96f6867312 | 4543 | } |
mjr | 5:a70c0bce770d | 4544 | |
mjr | 77:0b96f6867312 | 4545 | // report our integrated velocity reading in x,y |
mjr | 77:0b96f6867312 | 4546 | x = rawToReport(xSum/nSum); |
mjr | 77:0b96f6867312 | 4547 | y = rawToReport(ySum/nSum); |
mjr | 5:a70c0bce770d | 4548 | |
mjr | 6:cc35eb643e8f | 4549 | #ifdef DEBUG_PRINTF |
mjr | 77:0b96f6867312 | 4550 | if (x != 0 || y != 0) |
mjr | 77:0b96f6867312 | 4551 | printf("%f %f %d %d %f\r\n", vx, vy, x, y, dt); |
mjr | 6:cc35eb643e8f | 4552 | #endif |
mjr | 77:0b96f6867312 | 4553 | } |
mjr | 29:582472d0bc57 | 4554 | |
mjr | 3:3514575d4f86 | 4555 | private: |
mjr | 6:cc35eb643e8f | 4556 | // adjust a raw acceleration figure to a usb report value |
mjr | 77:0b96f6867312 | 4557 | int rawToReport(int v) |
mjr | 5:a70c0bce770d | 4558 | { |
mjr | 77:0b96f6867312 | 4559 | // Scale to the joystick report range. The accelerometer |
mjr | 77:0b96f6867312 | 4560 | // readings use the native 14-bit signed integer representation, |
mjr | 77:0b96f6867312 | 4561 | // so their scale is 2^13. |
mjr | 77:0b96f6867312 | 4562 | // |
mjr | 77:0b96f6867312 | 4563 | // The 1G range is special: it uses the 2G native hardware range, |
mjr | 77:0b96f6867312 | 4564 | // but rescales the result to a 1G range for the joystick reports. |
mjr | 77:0b96f6867312 | 4565 | // So for that mode, we divide by 4096 rather than 8192. All of |
mjr | 77:0b96f6867312 | 4566 | // the other modes map use the hardware scaling directly. |
mjr | 77:0b96f6867312 | 4567 | int i = v*JOYMAX; |
mjr | 77:0b96f6867312 | 4568 | i = (range_ == AccelRange1G ? i/4096 : i/8192); |
mjr | 5:a70c0bce770d | 4569 | |
mjr | 6:cc35eb643e8f | 4570 | // if it's near the center, scale it roughly as 20*(i/20)^2, |
mjr | 6:cc35eb643e8f | 4571 | // to suppress noise near the rest position |
mjr | 6:cc35eb643e8f | 4572 | static const int filter[] = { |
mjr | 6:cc35eb643e8f | 4573 | -18, -16, -14, -13, -11, -10, -8, -7, -6, -5, -4, -3, -2, -2, -1, -1, 0, 0, 0, 0, |
mjr | 6:cc35eb643e8f | 4574 | 0, |
mjr | 6:cc35eb643e8f | 4575 | 0, 0, 0, 0, 1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 10, 11, 13, 14, 16, 18 |
mjr | 6:cc35eb643e8f | 4576 | }; |
mjr | 6:cc35eb643e8f | 4577 | return (i > 20 || i < -20 ? i : filter[i+20]); |
mjr | 5:a70c0bce770d | 4578 | } |
mjr | 5:a70c0bce770d | 4579 | |
mjr | 3:3514575d4f86 | 4580 | // underlying accelerometer object |
mjr | 3:3514575d4f86 | 4581 | MMA8451Q mma_; |
mjr | 3:3514575d4f86 | 4582 | |
mjr | 77:0b96f6867312 | 4583 | // last raw acceleration readings, on the device's signed 14-bit |
mjr | 77:0b96f6867312 | 4584 | // scale -8192..+8191 |
mjr | 77:0b96f6867312 | 4585 | int ax_, ay_, az_; |
mjr | 77:0b96f6867312 | 4586 | |
mjr | 77:0b96f6867312 | 4587 | // running sum of readings since last get() |
mjr | 77:0b96f6867312 | 4588 | int xSum_, ySum_; |
mjr | 77:0b96f6867312 | 4589 | |
mjr | 77:0b96f6867312 | 4590 | // number of readings since last get() |
mjr | 77:0b96f6867312 | 4591 | int nSum_; |
mjr | 6:cc35eb643e8f | 4592 | |
mjr | 6:cc35eb643e8f | 4593 | // Calibration reference point for accelerometer. This is the |
mjr | 6:cc35eb643e8f | 4594 | // average reading on the accelerometer when in the neutral position |
mjr | 6:cc35eb643e8f | 4595 | // at rest. |
mjr | 77:0b96f6867312 | 4596 | int cx_, cy_; |
mjr | 77:0b96f6867312 | 4597 | |
mjr | 77:0b96f6867312 | 4598 | // range (AccelRangeXxx value, from config.h) |
mjr | 77:0b96f6867312 | 4599 | uint8_t range_; |
mjr | 78:1e00b3fa11af | 4600 | |
mjr | 78:1e00b3fa11af | 4601 | // auto-center mode: |
mjr | 78:1e00b3fa11af | 4602 | // 0 = default of 5-second auto-centering |
mjr | 78:1e00b3fa11af | 4603 | // 1-60 = auto-center after this many seconds |
mjr | 78:1e00b3fa11af | 4604 | // 255 = auto-centering off (manual centering only) |
mjr | 78:1e00b3fa11af | 4605 | uint8_t autoCenterMode_; |
mjr | 78:1e00b3fa11af | 4606 | |
mjr | 78:1e00b3fa11af | 4607 | // flag: a manual centering request is pending |
mjr | 78:1e00b3fa11af | 4608 | bool manualCenterRequest_; |
mjr | 78:1e00b3fa11af | 4609 | |
mjr | 78:1e00b3fa11af | 4610 | // time in us between auto-centering incremental checks |
mjr | 78:1e00b3fa11af | 4611 | uint32_t autoCenterCheckTime_; |
mjr | 78:1e00b3fa11af | 4612 | |
mjr | 77:0b96f6867312 | 4613 | // atuo-centering timer |
mjr | 5:a70c0bce770d | 4614 | Timer tCenter_; |
mjr | 112:8ed709f455c0 | 4615 | |
mjr | 6:cc35eb643e8f | 4616 | // Auto-centering history. This is a separate history list that |
mjr | 77:0b96f6867312 | 4617 | // records results spaced out sparsely over time, so that we can |
mjr | 6:cc35eb643e8f | 4618 | // watch for long-lasting periods of rest. When we observe nearly |
mjr | 6:cc35eb643e8f | 4619 | // no motion for an extended period (on the order of 5 seconds), we |
mjr | 6:cc35eb643e8f | 4620 | // take this to mean that the cabinet is at rest in its neutral |
mjr | 6:cc35eb643e8f | 4621 | // position, so we take this as the calibration zero point for the |
mjr | 6:cc35eb643e8f | 4622 | // accelerometer. We update this history continuously, which allows |
mjr | 6:cc35eb643e8f | 4623 | // us to continuously re-calibrate the accelerometer. This ensures |
mjr | 6:cc35eb643e8f | 4624 | // that we'll automatically adjust to any actual changes in the |
mjr | 6:cc35eb643e8f | 4625 | // cabinet's orientation (e.g., if it gets moved slightly by an |
mjr | 6:cc35eb643e8f | 4626 | // especially strong nudge) as well as any systematic drift in the |
mjr | 6:cc35eb643e8f | 4627 | // accelerometer measurement bias (e.g., from temperature changes). |
mjr | 78:1e00b3fa11af | 4628 | uint8_t iAccPrv_, nAccPrv_; |
mjr | 78:1e00b3fa11af | 4629 | static const uint8_t maxAccPrv = 5; |
mjr | 6:cc35eb643e8f | 4630 | AccHist accPrv_[maxAccPrv]; |
mjr | 3:3514575d4f86 | 4631 | }; |
mjr | 3:3514575d4f86 | 4632 | |
mjr | 76:7f5912b6340e | 4633 | |
mjr | 14:df700b22ca08 | 4634 | // --------------------------------------------------------------------------- |
mjr | 14:df700b22ca08 | 4635 | // |
mjr | 33:d832bcab089e | 4636 | // Simple binary (on/off) input debouncer. Requires an input to be stable |
mjr | 33:d832bcab089e | 4637 | // for a given interval before allowing an update. |
mjr | 33:d832bcab089e | 4638 | // |
mjr | 33:d832bcab089e | 4639 | class Debouncer |
mjr | 33:d832bcab089e | 4640 | { |
mjr | 33:d832bcab089e | 4641 | public: |
mjr | 33:d832bcab089e | 4642 | Debouncer(bool initVal, float tmin) |
mjr | 33:d832bcab089e | 4643 | { |
mjr | 33:d832bcab089e | 4644 | t.start(); |
mjr | 33:d832bcab089e | 4645 | this->stable = this->prv = initVal; |
mjr | 33:d832bcab089e | 4646 | this->tmin = tmin; |
mjr | 33:d832bcab089e | 4647 | } |
mjr | 33:d832bcab089e | 4648 | |
mjr | 33:d832bcab089e | 4649 | // Get the current stable value |
mjr | 33:d832bcab089e | 4650 | bool val() const { return stable; } |
mjr | 33:d832bcab089e | 4651 | |
mjr | 33:d832bcab089e | 4652 | // Apply a new sample. This tells us the new raw reading from the |
mjr | 33:d832bcab089e | 4653 | // input device. |
mjr | 33:d832bcab089e | 4654 | void sampleIn(bool val) |
mjr | 33:d832bcab089e | 4655 | { |
mjr | 33:d832bcab089e | 4656 | // If the new raw reading is different from the previous |
mjr | 33:d832bcab089e | 4657 | // raw reading, we've detected an edge - start the clock |
mjr | 33:d832bcab089e | 4658 | // on the sample reader. |
mjr | 33:d832bcab089e | 4659 | if (val != prv) |
mjr | 33:d832bcab089e | 4660 | { |
mjr | 33:d832bcab089e | 4661 | // we have an edge - reset the sample clock |
mjr | 33:d832bcab089e | 4662 | t.reset(); |
mjr | 33:d832bcab089e | 4663 | |
mjr | 33:d832bcab089e | 4664 | // this is now the previous raw sample for nxt time |
mjr | 33:d832bcab089e | 4665 | prv = val; |
mjr | 33:d832bcab089e | 4666 | } |
mjr | 33:d832bcab089e | 4667 | else if (val != stable) |
mjr | 33:d832bcab089e | 4668 | { |
mjr | 33:d832bcab089e | 4669 | // The new raw sample is the same as the last raw sample, |
mjr | 33:d832bcab089e | 4670 | // and different from the stable value. This means that |
mjr | 33:d832bcab089e | 4671 | // the sample value has been the same for the time currently |
mjr | 33:d832bcab089e | 4672 | // indicated by our timer. If enough time has elapsed to |
mjr | 33:d832bcab089e | 4673 | // consider the value stable, apply the new value. |
mjr | 33:d832bcab089e | 4674 | if (t.read() > tmin) |
mjr | 33:d832bcab089e | 4675 | stable = val; |
mjr | 33:d832bcab089e | 4676 | } |
mjr | 33:d832bcab089e | 4677 | } |
mjr | 33:d832bcab089e | 4678 | |
mjr | 33:d832bcab089e | 4679 | private: |
mjr | 33:d832bcab089e | 4680 | // current stable value |
mjr | 33:d832bcab089e | 4681 | bool stable; |
mjr | 33:d832bcab089e | 4682 | |
mjr | 33:d832bcab089e | 4683 | // last raw sample value |
mjr | 33:d832bcab089e | 4684 | bool prv; |
mjr | 33:d832bcab089e | 4685 | |
mjr | 33:d832bcab089e | 4686 | // elapsed time since last raw input change |
mjr | 33:d832bcab089e | 4687 | Timer t; |
mjr | 33:d832bcab089e | 4688 | |
mjr | 33:d832bcab089e | 4689 | // Minimum time interval for stability, in seconds. Input readings |
mjr | 33:d832bcab089e | 4690 | // must be stable for this long before the stable value is updated. |
mjr | 33:d832bcab089e | 4691 | float tmin; |
mjr | 33:d832bcab089e | 4692 | }; |
mjr | 33:d832bcab089e | 4693 | |
mjr | 33:d832bcab089e | 4694 | |
mjr | 33:d832bcab089e | 4695 | // --------------------------------------------------------------------------- |
mjr | 33:d832bcab089e | 4696 | // |
mjr | 33:d832bcab089e | 4697 | // TV ON timer. If this feature is enabled, we toggle a TV power switch |
mjr | 33:d832bcab089e | 4698 | // relay (connected to a GPIO pin) to turn on the cab's TV monitors shortly |
mjr | 33:d832bcab089e | 4699 | // after the system is powered. This is useful for TVs that don't remember |
mjr | 33:d832bcab089e | 4700 | // their power state and don't turn back on automatically after being |
mjr | 33:d832bcab089e | 4701 | // unplugged and plugged in again. This feature requires external |
mjr | 33:d832bcab089e | 4702 | // circuitry, which is built in to the expansion board and can also be |
mjr | 33:d832bcab089e | 4703 | // built separately - see the Build Guide for the circuit plan. |
mjr | 33:d832bcab089e | 4704 | // |
mjr | 33:d832bcab089e | 4705 | // Theory of operation: to use this feature, the cabinet must have a |
mjr | 33:d832bcab089e | 4706 | // secondary PC-style power supply (PSU2) for the feedback devices, and |
mjr | 33:d832bcab089e | 4707 | // this secondary supply must be plugged in to the same power strip or |
mjr | 33:d832bcab089e | 4708 | // switched outlet that controls power to the TVs. This lets us use PSU2 |
mjr | 33:d832bcab089e | 4709 | // as a proxy for the TV power state - when PSU2 is on, the TV outlet is |
mjr | 33:d832bcab089e | 4710 | // powered, and when PSU2 is off, the TV outlet is off. We use a little |
mjr | 33:d832bcab089e | 4711 | // latch circuit powered by PSU2 to monitor the status. The latch has a |
mjr | 33:d832bcab089e | 4712 | // current state, ON or OFF, that we can read via a GPIO input pin, and |
mjr | 33:d832bcab089e | 4713 | // we can set the state to ON by pulsing a separate GPIO output pin. As |
mjr | 33:d832bcab089e | 4714 | // long as PSU2 is powered off, the latch stays in the OFF state, even if |
mjr | 33:d832bcab089e | 4715 | // we try to set it by pulsing the SET pin. When PSU2 is turned on after |
mjr | 33:d832bcab089e | 4716 | // being off, the latch starts receiving power but stays in the OFF state, |
mjr | 33:d832bcab089e | 4717 | // since this is the initial condition when the power first comes on. So |
mjr | 33:d832bcab089e | 4718 | // if our latch state pin is reading OFF, we know that PSU2 is either off |
mjr | 33:d832bcab089e | 4719 | // now or *was* off some time since we last checked. We use a timer to |
mjr | 33:d832bcab089e | 4720 | // check the state periodically. Each time we see the state is OFF, we |
mjr | 33:d832bcab089e | 4721 | // try pulsing the SET pin. If the state still reads as OFF, we know |
mjr | 33:d832bcab089e | 4722 | // that PSU2 is currently off; if the state changes to ON, though, we |
mjr | 33:d832bcab089e | 4723 | // know that PSU2 has gone from OFF to ON some time between now and the |
mjr | 33:d832bcab089e | 4724 | // previous check. When we see this condition, we start a countdown |
mjr | 33:d832bcab089e | 4725 | // timer, and pulse the TV switch relay when the countdown ends. |
mjr | 33:d832bcab089e | 4726 | // |
mjr | 40:cc0d9814522b | 4727 | // This scheme might seem a little convoluted, but it handles a number |
mjr | 40:cc0d9814522b | 4728 | // of tricky but likely scenarios: |
mjr | 33:d832bcab089e | 4729 | // |
mjr | 33:d832bcab089e | 4730 | // - Most cabinets systems are set up with "soft" PC power switches, |
mjr | 40:cc0d9814522b | 4731 | // so that the PC goes into "Soft Off" mode when the user turns off |
mjr | 40:cc0d9814522b | 4732 | // the cabinet by pushing the power button or using the Shut Down |
mjr | 40:cc0d9814522b | 4733 | // command from within Windows. In Windows parlance, this "soft off" |
mjr | 40:cc0d9814522b | 4734 | // condition is called ACPI State S5. In this state, the main CPU |
mjr | 40:cc0d9814522b | 4735 | // power is turned off, but the motherboard still provides power to |
mjr | 40:cc0d9814522b | 4736 | // USB devices. This means that the KL25Z keeps running. Without |
mjr | 40:cc0d9814522b | 4737 | // the external power sensing circuit, the only hint that we're in |
mjr | 40:cc0d9814522b | 4738 | // this state is that the USB connection to the host goes into Suspend |
mjr | 40:cc0d9814522b | 4739 | // mode, but that could mean other things as well. The latch circuit |
mjr | 40:cc0d9814522b | 4740 | // lets us tell for sure that we're in this state. |
mjr | 33:d832bcab089e | 4741 | // |
mjr | 33:d832bcab089e | 4742 | // - Some cabinet builders might prefer to use "hard" power switches, |
mjr | 33:d832bcab089e | 4743 | // cutting all power to the cabinet, including the PC motherboard (and |
mjr | 33:d832bcab089e | 4744 | // thus the KL25Z) every time the machine is turned off. This also |
mjr | 33:d832bcab089e | 4745 | // applies to the "soft" switch case above when the cabinet is unplugged, |
mjr | 33:d832bcab089e | 4746 | // a power outage occurs, etc. In these cases, the KL25Z will do a cold |
mjr | 33:d832bcab089e | 4747 | // boot when the PC is turned on. We don't know whether the KL25Z |
mjr | 33:d832bcab089e | 4748 | // will power up before or after PSU2, so it's not good enough to |
mjr | 40:cc0d9814522b | 4749 | // observe the current state of PSU2 when we first check. If PSU2 |
mjr | 40:cc0d9814522b | 4750 | // were to come on first, checking only the current state would fool |
mjr | 40:cc0d9814522b | 4751 | // us into thinking that no action is required, because we'd only see |
mjr | 40:cc0d9814522b | 4752 | // that PSU2 is turned on any time we check. The latch handles this |
mjr | 40:cc0d9814522b | 4753 | // case by letting us see that PSU2 was indeed off some time before our |
mjr | 40:cc0d9814522b | 4754 | // first check. |
mjr | 33:d832bcab089e | 4755 | // |
mjr | 33:d832bcab089e | 4756 | // - If the KL25Z is rebooted while the main system is running, or the |
mjr | 40:cc0d9814522b | 4757 | // KL25Z is unplugged and plugged back in, we'll correctly leave the |
mjr | 33:d832bcab089e | 4758 | // TVs as they are. The latch state is independent of the KL25Z's |
mjr | 33:d832bcab089e | 4759 | // power or software state, so it's won't affect the latch state when |
mjr | 33:d832bcab089e | 4760 | // the KL25Z is unplugged or rebooted; when we boot, we'll see that |
mjr | 33:d832bcab089e | 4761 | // the latch is already on and that we don't have to turn on the TVs. |
mjr | 33:d832bcab089e | 4762 | // This is important because TV ON buttons are usually on/off toggles, |
mjr | 33:d832bcab089e | 4763 | // so we don't want to push the button on a TV that's already on. |
mjr | 33:d832bcab089e | 4764 | // |
mjr | 33:d832bcab089e | 4765 | |
mjr | 77:0b96f6867312 | 4766 | // Current PSU2 power state: |
mjr | 33:d832bcab089e | 4767 | // 1 -> default: latch was on at last check, or we haven't checked yet |
mjr | 33:d832bcab089e | 4768 | // 2 -> latch was off at last check, SET pulsed high |
mjr | 33:d832bcab089e | 4769 | // 3 -> SET pulsed low, ready to check status |
mjr | 33:d832bcab089e | 4770 | // 4 -> TV timer countdown in progress |
mjr | 33:d832bcab089e | 4771 | // 5 -> TV relay on |
mjr | 77:0b96f6867312 | 4772 | // 6 -> sending IR signals designed as TV ON signals |
mjr | 73:4e8ce0b18915 | 4773 | uint8_t psu2_state = 1; |
mjr | 73:4e8ce0b18915 | 4774 | |
mjr | 73:4e8ce0b18915 | 4775 | // TV relay state. The TV relay can be controlled by the power-on |
mjr | 73:4e8ce0b18915 | 4776 | // timer and directly from the PC (via USB commands), so keep a |
mjr | 73:4e8ce0b18915 | 4777 | // separate state for each: |
mjr | 73:4e8ce0b18915 | 4778 | // 0x01 -> turned on by power-on timer |
mjr | 73:4e8ce0b18915 | 4779 | // 0x02 -> turned on by USB command |
mjr | 73:4e8ce0b18915 | 4780 | uint8_t tv_relay_state = 0x00; |
mjr | 73:4e8ce0b18915 | 4781 | const uint8_t TV_RELAY_POWERON = 0x01; |
mjr | 73:4e8ce0b18915 | 4782 | const uint8_t TV_RELAY_USB = 0x02; |
mjr | 73:4e8ce0b18915 | 4783 | |
mjr | 79:682ae3171a08 | 4784 | // pulse timer for manual TV relay pulses |
mjr | 79:682ae3171a08 | 4785 | Timer tvRelayManualTimer; |
mjr | 79:682ae3171a08 | 4786 | |
mjr | 77:0b96f6867312 | 4787 | // TV ON IR command state. When the main PSU2 power state reaches |
mjr | 77:0b96f6867312 | 4788 | // the IR phase, we use this sub-state counter to send the TV ON |
mjr | 77:0b96f6867312 | 4789 | // IR signals. We initialize to state 0 when the main state counter |
mjr | 77:0b96f6867312 | 4790 | // reaches the IR step. In state 0, we start transmitting the first |
mjr | 77:0b96f6867312 | 4791 | // (lowest numbered) IR command slot marked as containing a TV ON |
mjr | 77:0b96f6867312 | 4792 | // code, and advance to state 1. In state 1, we check to see if |
mjr | 77:0b96f6867312 | 4793 | // the transmitter is still sending; if so, we do nothing, if so |
mjr | 77:0b96f6867312 | 4794 | // we start transmitting the second TV ON code and advance to state |
mjr | 77:0b96f6867312 | 4795 | // 2. Continue until we run out of TV ON IR codes, at which point |
mjr | 77:0b96f6867312 | 4796 | // we advance to the next main psu2_state step. |
mjr | 77:0b96f6867312 | 4797 | uint8_t tvon_ir_state = 0; |
mjr | 77:0b96f6867312 | 4798 | |
mjr | 77:0b96f6867312 | 4799 | // TV ON switch relay control output pin |
mjr | 73:4e8ce0b18915 | 4800 | DigitalOut *tv_relay; |
mjr | 35:e959ffba78fd | 4801 | |
mjr | 35:e959ffba78fd | 4802 | // PSU2 power sensing circuit connections |
mjr | 35:e959ffba78fd | 4803 | DigitalIn *psu2_status_sense; |
mjr | 35:e959ffba78fd | 4804 | DigitalOut *psu2_status_set; |
mjr | 35:e959ffba78fd | 4805 | |
mjr | 73:4e8ce0b18915 | 4806 | // Apply the current TV relay state |
mjr | 73:4e8ce0b18915 | 4807 | void tvRelayUpdate(uint8_t bit, bool state) |
mjr | 73:4e8ce0b18915 | 4808 | { |
mjr | 73:4e8ce0b18915 | 4809 | // update the state |
mjr | 73:4e8ce0b18915 | 4810 | if (state) |
mjr | 73:4e8ce0b18915 | 4811 | tv_relay_state |= bit; |
mjr | 73:4e8ce0b18915 | 4812 | else |
mjr | 73:4e8ce0b18915 | 4813 | tv_relay_state &= ~bit; |
mjr | 73:4e8ce0b18915 | 4814 | |
mjr | 73:4e8ce0b18915 | 4815 | // set the relay GPIO to the new state |
mjr | 73:4e8ce0b18915 | 4816 | if (tv_relay != 0) |
mjr | 73:4e8ce0b18915 | 4817 | tv_relay->write(tv_relay_state != 0); |
mjr | 73:4e8ce0b18915 | 4818 | } |
mjr | 35:e959ffba78fd | 4819 | |
mjr | 86:e30a1f60f783 | 4820 | // Does the current power status allow a reboot? We shouldn't reboot |
mjr | 86:e30a1f60f783 | 4821 | // in certain power states, because some states are purely internal: |
mjr | 86:e30a1f60f783 | 4822 | // we can't get enough information from the external power sensor to |
mjr | 86:e30a1f60f783 | 4823 | // return to the same state later. Code that performs discretionary |
mjr | 86:e30a1f60f783 | 4824 | // reboots should always check here first, and delay any reboot until |
mjr | 86:e30a1f60f783 | 4825 | // we say it's okay. |
mjr | 86:e30a1f60f783 | 4826 | static inline bool powerStatusAllowsReboot() |
mjr | 86:e30a1f60f783 | 4827 | { |
mjr | 86:e30a1f60f783 | 4828 | // The only safe state for rebooting is state 1, idle/default. |
mjr | 86:e30a1f60f783 | 4829 | // In other states, we can't reboot, because the external sensor |
mjr | 86:e30a1f60f783 | 4830 | // and latch circuit doesn't give us enough information to return |
mjr | 86:e30a1f60f783 | 4831 | // to the same state later. |
mjr | 86:e30a1f60f783 | 4832 | return psu2_state == 1; |
mjr | 86:e30a1f60f783 | 4833 | } |
mjr | 86:e30a1f60f783 | 4834 | |
mjr | 77:0b96f6867312 | 4835 | // PSU2 Status update routine. The main loop calls this from time |
mjr | 77:0b96f6867312 | 4836 | // to time to update the power sensing state and carry out TV ON |
mjr | 77:0b96f6867312 | 4837 | // functions. |
mjr | 77:0b96f6867312 | 4838 | Timer powerStatusTimer; |
mjr | 77:0b96f6867312 | 4839 | uint32_t tv_delay_time_us; |
mjr | 77:0b96f6867312 | 4840 | void powerStatusUpdate(Config &cfg) |
mjr | 33:d832bcab089e | 4841 | { |
mjr | 79:682ae3171a08 | 4842 | // If the manual relay pulse timer is past the pulse time, end the |
mjr | 79:682ae3171a08 | 4843 | // manual pulse. The timer only runs when a pulse is active, so |
mjr | 79:682ae3171a08 | 4844 | // it'll never read as past the time limit if a pulse isn't on. |
mjr | 79:682ae3171a08 | 4845 | if (tvRelayManualTimer.read_us() > 250000) |
mjr | 79:682ae3171a08 | 4846 | { |
mjr | 79:682ae3171a08 | 4847 | // turn off the relay and disable the timer |
mjr | 79:682ae3171a08 | 4848 | tvRelayUpdate(TV_RELAY_USB, false); |
mjr | 79:682ae3171a08 | 4849 | tvRelayManualTimer.stop(); |
mjr | 79:682ae3171a08 | 4850 | tvRelayManualTimer.reset(); |
mjr | 79:682ae3171a08 | 4851 | } |
mjr | 79:682ae3171a08 | 4852 | |
mjr | 77:0b96f6867312 | 4853 | // Only update every 1/4 second or so. Note that if the PSU2 |
mjr | 77:0b96f6867312 | 4854 | // circuit isn't configured, the initialization routine won't |
mjr | 77:0b96f6867312 | 4855 | // start the timer, so it'll always read zero and we'll always |
mjr | 77:0b96f6867312 | 4856 | // skip this whole routine. |
mjr | 77:0b96f6867312 | 4857 | if (powerStatusTimer.read_us() < 250000) |
mjr | 77:0b96f6867312 | 4858 | return; |
mjr | 77:0b96f6867312 | 4859 | |
mjr | 77:0b96f6867312 | 4860 | // reset the update timer for next time |
mjr | 77:0b96f6867312 | 4861 | powerStatusTimer.reset(); |
mjr | 77:0b96f6867312 | 4862 | |
mjr | 77:0b96f6867312 | 4863 | // TV ON timer. We start this timer when we detect a change |
mjr | 77:0b96f6867312 | 4864 | // in the PSU2 status from OFF to ON. When the timer reaches |
mjr | 77:0b96f6867312 | 4865 | // the configured TV ON delay time, and the PSU2 power is still |
mjr | 77:0b96f6867312 | 4866 | // on, we'll trigger the TV ON relay and send the TV ON IR codes. |
mjr | 35:e959ffba78fd | 4867 | static Timer tv_timer; |
mjr | 35:e959ffba78fd | 4868 | |
mjr | 33:d832bcab089e | 4869 | // Check our internal state |
mjr | 33:d832bcab089e | 4870 | switch (psu2_state) |
mjr | 33:d832bcab089e | 4871 | { |
mjr | 33:d832bcab089e | 4872 | case 1: |
mjr | 33:d832bcab089e | 4873 | // Default state. This means that the latch was on last |
mjr | 33:d832bcab089e | 4874 | // time we checked or that this is the first check. In |
mjr | 33:d832bcab089e | 4875 | // either case, if the latch is off, switch to state 2 and |
mjr | 33:d832bcab089e | 4876 | // try pulsing the latch. Next time we check, if the latch |
mjr | 33:d832bcab089e | 4877 | // stuck, it means that PSU2 is now on after being off. |
mjr | 35:e959ffba78fd | 4878 | if (!psu2_status_sense->read()) |
mjr | 33:d832bcab089e | 4879 | { |
mjr | 33:d832bcab089e | 4880 | // switch to OFF state |
mjr | 33:d832bcab089e | 4881 | psu2_state = 2; |
mjr | 33:d832bcab089e | 4882 | |
mjr | 33:d832bcab089e | 4883 | // try setting the latch |
mjr | 35:e959ffba78fd | 4884 | psu2_status_set->write(1); |
mjr | 33:d832bcab089e | 4885 | } |
mjr | 77:0b96f6867312 | 4886 | powerTimerDiagState = 0; |
mjr | 33:d832bcab089e | 4887 | break; |
mjr | 33:d832bcab089e | 4888 | |
mjr | 33:d832bcab089e | 4889 | case 2: |
mjr | 33:d832bcab089e | 4890 | // PSU2 was off last time we checked, and we tried setting |
mjr | 33:d832bcab089e | 4891 | // the latch. Drop the SET signal and go to CHECK state. |
mjr | 35:e959ffba78fd | 4892 | psu2_status_set->write(0); |
mjr | 33:d832bcab089e | 4893 | psu2_state = 3; |
mjr | 77:0b96f6867312 | 4894 | powerTimerDiagState = 0; |
mjr | 33:d832bcab089e | 4895 | break; |
mjr | 33:d832bcab089e | 4896 | |
mjr | 33:d832bcab089e | 4897 | case 3: |
mjr | 33:d832bcab089e | 4898 | // CHECK state: we pulsed SET, and we're now ready to see |
mjr | 40:cc0d9814522b | 4899 | // if it stuck. If the latch is now on, PSU2 has transitioned |
mjr | 33:d832bcab089e | 4900 | // from OFF to ON, so start the TV countdown. If the latch is |
mjr | 33:d832bcab089e | 4901 | // off, our SET command didn't stick, so PSU2 is still off. |
mjr | 35:e959ffba78fd | 4902 | if (psu2_status_sense->read()) |
mjr | 33:d832bcab089e | 4903 | { |
mjr | 33:d832bcab089e | 4904 | // The latch stuck, so PSU2 has transitioned from OFF |
mjr | 33:d832bcab089e | 4905 | // to ON. Start the TV countdown timer. |
mjr | 33:d832bcab089e | 4906 | tv_timer.reset(); |
mjr | 33:d832bcab089e | 4907 | tv_timer.start(); |
mjr | 33:d832bcab089e | 4908 | psu2_state = 4; |
mjr | 73:4e8ce0b18915 | 4909 | |
mjr | 73:4e8ce0b18915 | 4910 | // start the power timer diagnostic flashes |
mjr | 73:4e8ce0b18915 | 4911 | powerTimerDiagState = 2; |
mjr | 33:d832bcab089e | 4912 | } |
mjr | 33:d832bcab089e | 4913 | else |
mjr | 33:d832bcab089e | 4914 | { |
mjr | 33:d832bcab089e | 4915 | // The latch didn't stick, so PSU2 was still off at |
mjr | 87:8d35c74403af | 4916 | // our last check. Return to idle state. |
mjr | 87:8d35c74403af | 4917 | psu2_state = 1; |
mjr | 33:d832bcab089e | 4918 | } |
mjr | 33:d832bcab089e | 4919 | break; |
mjr | 33:d832bcab089e | 4920 | |
mjr | 33:d832bcab089e | 4921 | case 4: |
mjr | 77:0b96f6867312 | 4922 | // TV timer countdown in progress. The latch has to stay on during |
mjr | 77:0b96f6867312 | 4923 | // the countdown; if the latch turns off, PSU2 power must have gone |
mjr | 77:0b96f6867312 | 4924 | // off again before the countdown finished. |
mjr | 77:0b96f6867312 | 4925 | if (!psu2_status_sense->read()) |
mjr | 77:0b96f6867312 | 4926 | { |
mjr | 77:0b96f6867312 | 4927 | // power is off - start a new check cycle |
mjr | 77:0b96f6867312 | 4928 | psu2_status_set->write(1); |
mjr | 77:0b96f6867312 | 4929 | psu2_state = 2; |
mjr | 77:0b96f6867312 | 4930 | break; |
mjr | 77:0b96f6867312 | 4931 | } |
mjr | 77:0b96f6867312 | 4932 | |
mjr | 77:0b96f6867312 | 4933 | // Flash the power time diagnostic every two cycles |
mjr | 77:0b96f6867312 | 4934 | powerTimerDiagState = (powerTimerDiagState + 1) & 0x03; |
mjr | 77:0b96f6867312 | 4935 | |
mjr | 77:0b96f6867312 | 4936 | // if we've reached the delay time, pulse the relay |
mjr | 77:0b96f6867312 | 4937 | if (tv_timer.read_us() >= tv_delay_time_us) |
mjr | 33:d832bcab089e | 4938 | { |
mjr | 33:d832bcab089e | 4939 | // turn on the relay for one timer interval |
mjr | 73:4e8ce0b18915 | 4940 | tvRelayUpdate(TV_RELAY_POWERON, true); |
mjr | 33:d832bcab089e | 4941 | psu2_state = 5; |
mjr | 77:0b96f6867312 | 4942 | |
mjr | 77:0b96f6867312 | 4943 | // show solid blue on the diagnostic LED while the relay is on |
mjr | 77:0b96f6867312 | 4944 | powerTimerDiagState = 2; |
mjr | 33:d832bcab089e | 4945 | } |
mjr | 33:d832bcab089e | 4946 | break; |
mjr | 33:d832bcab089e | 4947 | |
mjr | 33:d832bcab089e | 4948 | case 5: |
mjr | 33:d832bcab089e | 4949 | // TV timer relay on. We pulse this for one interval, so |
mjr | 77:0b96f6867312 | 4950 | // it's now time to turn it off. |
mjr | 73:4e8ce0b18915 | 4951 | tvRelayUpdate(TV_RELAY_POWERON, false); |
mjr | 77:0b96f6867312 | 4952 | |
mjr | 77:0b96f6867312 | 4953 | // Proceed to sending any TV ON IR commands |
mjr | 77:0b96f6867312 | 4954 | psu2_state = 6; |
mjr | 77:0b96f6867312 | 4955 | tvon_ir_state = 0; |
mjr | 77:0b96f6867312 | 4956 | |
mjr | 77:0b96f6867312 | 4957 | // diagnostic LEDs off for now |
mjr | 77:0b96f6867312 | 4958 | powerTimerDiagState = 0; |
mjr | 77:0b96f6867312 | 4959 | break; |
mjr | 77:0b96f6867312 | 4960 | |
mjr | 77:0b96f6867312 | 4961 | case 6: |
mjr | 77:0b96f6867312 | 4962 | // Sending TV ON IR signals. Start with the assumption that |
mjr | 77:0b96f6867312 | 4963 | // we have no IR work to do, in which case we're done with the |
mjr | 77:0b96f6867312 | 4964 | // whole TV ON sequence. So by default return to state 1. |
mjr | 33:d832bcab089e | 4965 | psu2_state = 1; |
mjr | 77:0b96f6867312 | 4966 | powerTimerDiagState = 0; |
mjr | 73:4e8ce0b18915 | 4967 | |
mjr | 77:0b96f6867312 | 4968 | // If we have an IR emitter, check for TV ON IR commands |
mjr | 77:0b96f6867312 | 4969 | if (ir_tx != 0) |
mjr | 77:0b96f6867312 | 4970 | { |
mjr | 77:0b96f6867312 | 4971 | // check to see if the last transmission is still in progress |
mjr | 77:0b96f6867312 | 4972 | if (ir_tx->isSending()) |
mjr | 77:0b96f6867312 | 4973 | { |
mjr | 77:0b96f6867312 | 4974 | // We're still sending the last transmission. Stay in |
mjr | 77:0b96f6867312 | 4975 | // state 6. |
mjr | 77:0b96f6867312 | 4976 | psu2_state = 6; |
mjr | 77:0b96f6867312 | 4977 | powerTimerDiagState = 4; |
mjr | 77:0b96f6867312 | 4978 | break; |
mjr | 77:0b96f6867312 | 4979 | } |
mjr | 77:0b96f6867312 | 4980 | |
mjr | 77:0b96f6867312 | 4981 | // The last transmission is done, so check for a new one. |
mjr | 77:0b96f6867312 | 4982 | // Look for the Nth TV ON IR slot, where N is our state |
mjr | 77:0b96f6867312 | 4983 | // number. |
mjr | 77:0b96f6867312 | 4984 | for (int i = 0, n = 0 ; i < MAX_IR_CODES ; ++i) |
mjr | 77:0b96f6867312 | 4985 | { |
mjr | 77:0b96f6867312 | 4986 | // is this a TV ON command? |
mjr | 77:0b96f6867312 | 4987 | if ((cfg.IRCommand[i].flags & IRFlagTVON) != 0) |
mjr | 77:0b96f6867312 | 4988 | { |
mjr | 77:0b96f6867312 | 4989 | // It's a TV ON command - check if it's the one we're |
mjr | 109:310ac82cbbee | 4990 | // looking for. We can match any code starting at the |
mjr | 109:310ac82cbbee | 4991 | // current state. (We ignore codes BEFORE the current |
mjr | 109:310ac82cbbee | 4992 | // state, because we've already processed them on past |
mjr | 109:310ac82cbbee | 4993 | // iterations.) |
mjr | 109:310ac82cbbee | 4994 | if (n >= tvon_ir_state) |
mjr | 77:0b96f6867312 | 4995 | { |
mjr | 77:0b96f6867312 | 4996 | // It's the one. Start transmitting it by |
mjr | 77:0b96f6867312 | 4997 | // pushing its virtual button. |
mjr | 77:0b96f6867312 | 4998 | int vb = IRConfigSlotToVirtualButton[i]; |
mjr | 77:0b96f6867312 | 4999 | ir_tx->pushButton(vb, true); |
mjr | 77:0b96f6867312 | 5000 | |
mjr | 77:0b96f6867312 | 5001 | // Pushing the button starts transmission, and once |
mjr | 88:98bce687e6c0 | 5002 | // started, the transmission runs to completion even |
mjr | 88:98bce687e6c0 | 5003 | // if the button is no longer pushed. So we can |
mjr | 88:98bce687e6c0 | 5004 | // immediately un-push the button, since we only need |
mjr | 88:98bce687e6c0 | 5005 | // to send the code once. |
mjr | 77:0b96f6867312 | 5006 | ir_tx->pushButton(vb, false); |
mjr | 77:0b96f6867312 | 5007 | |
mjr | 77:0b96f6867312 | 5008 | // Advance to the next TV ON IR state, where we'll |
mjr | 77:0b96f6867312 | 5009 | // await the end of this transmission and move on to |
mjr | 77:0b96f6867312 | 5010 | // the next one. |
mjr | 77:0b96f6867312 | 5011 | psu2_state = 6; |
mjr | 77:0b96f6867312 | 5012 | tvon_ir_state++; |
mjr | 77:0b96f6867312 | 5013 | break; |
mjr | 77:0b96f6867312 | 5014 | } |
mjr | 77:0b96f6867312 | 5015 | |
mjr | 77:0b96f6867312 | 5016 | // it's not ours - count it and keep looking |
mjr | 77:0b96f6867312 | 5017 | ++n; |
mjr | 77:0b96f6867312 | 5018 | } |
mjr | 77:0b96f6867312 | 5019 | } |
mjr | 77:0b96f6867312 | 5020 | } |
mjr | 33:d832bcab089e | 5021 | break; |
mjr | 33:d832bcab089e | 5022 | } |
mjr | 77:0b96f6867312 | 5023 | |
mjr | 77:0b96f6867312 | 5024 | // update the diagnostic LEDs |
mjr | 77:0b96f6867312 | 5025 | diagLED(); |
mjr | 33:d832bcab089e | 5026 | } |
mjr | 33:d832bcab089e | 5027 | |
mjr | 77:0b96f6867312 | 5028 | // Start the power status timer. If the status sense circuit is enabled |
mjr | 77:0b96f6867312 | 5029 | // in the configuration, we'll set up the pin connections and start the |
mjr | 77:0b96f6867312 | 5030 | // timer for our periodic status checks. Does nothing if any of the pins |
mjr | 77:0b96f6867312 | 5031 | // are configured as NC. |
mjr | 77:0b96f6867312 | 5032 | void startPowerStatusTimer(Config &cfg) |
mjr | 35:e959ffba78fd | 5033 | { |
mjr | 55:4db125cd11a0 | 5034 | // only start the timer if the pins are configured and the delay |
mjr | 55:4db125cd11a0 | 5035 | // time is nonzero |
mjr | 77:0b96f6867312 | 5036 | powerStatusTimer.reset(); |
mjr | 77:0b96f6867312 | 5037 | if (cfg.TVON.statusPin != 0xFF |
mjr | 77:0b96f6867312 | 5038 | && cfg.TVON.latchPin != 0xFF) |
mjr | 35:e959ffba78fd | 5039 | { |
mjr | 77:0b96f6867312 | 5040 | // set up the power sensing circuit connections |
mjr | 53:9b2611964afc | 5041 | psu2_status_sense = new DigitalIn(wirePinName(cfg.TVON.statusPin)); |
mjr | 53:9b2611964afc | 5042 | psu2_status_set = new DigitalOut(wirePinName(cfg.TVON.latchPin)); |
mjr | 77:0b96f6867312 | 5043 | |
mjr | 77:0b96f6867312 | 5044 | // if there's a TV ON relay, set up its control pin |
mjr | 77:0b96f6867312 | 5045 | if (cfg.TVON.relayPin != 0xFF) |
mjr | 77:0b96f6867312 | 5046 | tv_relay = new DigitalOut(wirePinName(cfg.TVON.relayPin)); |
mjr | 77:0b96f6867312 | 5047 | |
mjr | 77:0b96f6867312 | 5048 | // Set the TV ON delay time. We store the time internally in |
mjr | 77:0b96f6867312 | 5049 | // microseconds, but the configuration stores it in units of |
mjr | 77:0b96f6867312 | 5050 | // 1/100 second = 10ms = 10000us. |
mjr | 77:0b96f6867312 | 5051 | tv_delay_time_us = cfg.TVON.delayTime * 10000;; |
mjr | 77:0b96f6867312 | 5052 | |
mjr | 77:0b96f6867312 | 5053 | // Start the TV timer |
mjr | 77:0b96f6867312 | 5054 | powerStatusTimer.start(); |
mjr | 35:e959ffba78fd | 5055 | } |
mjr | 35:e959ffba78fd | 5056 | } |
mjr | 35:e959ffba78fd | 5057 | |
mjr | 73:4e8ce0b18915 | 5058 | // Operate the TV ON relay. This allows manual control of the relay |
mjr | 73:4e8ce0b18915 | 5059 | // from the PC. See protocol message 65 submessage 11. |
mjr | 73:4e8ce0b18915 | 5060 | // |
mjr | 73:4e8ce0b18915 | 5061 | // Mode: |
mjr | 73:4e8ce0b18915 | 5062 | // 0 = turn relay off |
mjr | 73:4e8ce0b18915 | 5063 | // 1 = turn relay on |
mjr | 73:4e8ce0b18915 | 5064 | // 2 = pulse relay |
mjr | 73:4e8ce0b18915 | 5065 | void TVRelay(int mode) |
mjr | 73:4e8ce0b18915 | 5066 | { |
mjr | 73:4e8ce0b18915 | 5067 | // if there's no TV relay control pin, ignore this |
mjr | 73:4e8ce0b18915 | 5068 | if (tv_relay == 0) |
mjr | 73:4e8ce0b18915 | 5069 | return; |
mjr | 73:4e8ce0b18915 | 5070 | |
mjr | 73:4e8ce0b18915 | 5071 | switch (mode) |
mjr | 73:4e8ce0b18915 | 5072 | { |
mjr | 73:4e8ce0b18915 | 5073 | case 0: |
mjr | 73:4e8ce0b18915 | 5074 | // relay off |
mjr | 73:4e8ce0b18915 | 5075 | tvRelayUpdate(TV_RELAY_USB, false); |
mjr | 73:4e8ce0b18915 | 5076 | break; |
mjr | 73:4e8ce0b18915 | 5077 | |
mjr | 73:4e8ce0b18915 | 5078 | case 1: |
mjr | 73:4e8ce0b18915 | 5079 | // relay on |
mjr | 73:4e8ce0b18915 | 5080 | tvRelayUpdate(TV_RELAY_USB, true); |
mjr | 73:4e8ce0b18915 | 5081 | break; |
mjr | 73:4e8ce0b18915 | 5082 | |
mjr | 73:4e8ce0b18915 | 5083 | case 2: |
mjr | 79:682ae3171a08 | 5084 | // Turn the relay on and reset the manual TV pulse timer |
mjr | 73:4e8ce0b18915 | 5085 | tvRelayUpdate(TV_RELAY_USB, true); |
mjr | 79:682ae3171a08 | 5086 | tvRelayManualTimer.reset(); |
mjr | 79:682ae3171a08 | 5087 | tvRelayManualTimer.start(); |
mjr | 73:4e8ce0b18915 | 5088 | break; |
mjr | 73:4e8ce0b18915 | 5089 | } |
mjr | 73:4e8ce0b18915 | 5090 | } |
mjr | 73:4e8ce0b18915 | 5091 | |
mjr | 73:4e8ce0b18915 | 5092 | |
mjr | 35:e959ffba78fd | 5093 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 5094 | // |
mjr | 35:e959ffba78fd | 5095 | // In-memory configuration data structure. This is the live version in RAM |
mjr | 35:e959ffba78fd | 5096 | // that we use to determine how things are set up. |
mjr | 35:e959ffba78fd | 5097 | // |
mjr | 35:e959ffba78fd | 5098 | // When we save the configuration settings, we copy this structure to |
mjr | 35:e959ffba78fd | 5099 | // non-volatile flash memory. At startup, we check the flash location where |
mjr | 35:e959ffba78fd | 5100 | // we might have saved settings on a previous run, and it's valid, we copy |
mjr | 35:e959ffba78fd | 5101 | // the flash data to this structure. Firmware updates wipe the flash |
mjr | 35:e959ffba78fd | 5102 | // memory area, so you have to use the PC config tool to send the settings |
mjr | 35:e959ffba78fd | 5103 | // again each time the firmware is updated. |
mjr | 35:e959ffba78fd | 5104 | // |
mjr | 35:e959ffba78fd | 5105 | NVM nvm; |
mjr | 35:e959ffba78fd | 5106 | |
mjr | 86:e30a1f60f783 | 5107 | // Save Config followup time, in seconds. After a successful save, |
mjr | 86:e30a1f60f783 | 5108 | // we leave the success flag on in the status for this interval. At |
mjr | 86:e30a1f60f783 | 5109 | // the end of the interval, we reboot the device if requested. |
mjr | 86:e30a1f60f783 | 5110 | uint8_t saveConfigFollowupTime; |
mjr | 86:e30a1f60f783 | 5111 | |
mjr | 86:e30a1f60f783 | 5112 | // is a reboot pending at the end of the config save followup interval? |
mjr | 86:e30a1f60f783 | 5113 | uint8_t saveConfigRebootPending; |
mjr | 77:0b96f6867312 | 5114 | |
mjr | 79:682ae3171a08 | 5115 | // status flag for successful config save - set to 0x40 on success |
mjr | 79:682ae3171a08 | 5116 | uint8_t saveConfigSucceededFlag; |
mjr | 79:682ae3171a08 | 5117 | |
mjr | 86:e30a1f60f783 | 5118 | // Timer for configuration change followup timer |
mjr | 86:e30a1f60f783 | 5119 | ExtTimer saveConfigFollowupTimer; |
mjr | 86:e30a1f60f783 | 5120 | |
mjr | 86:e30a1f60f783 | 5121 | |
mjr | 35:e959ffba78fd | 5122 | // For convenience, a macro for the Config part of the NVM structure |
mjr | 35:e959ffba78fd | 5123 | #define cfg (nvm.d.c) |
mjr | 35:e959ffba78fd | 5124 | |
mjr | 35:e959ffba78fd | 5125 | // flash memory controller interface |
mjr | 35:e959ffba78fd | 5126 | FreescaleIAP iap; |
mjr | 35:e959ffba78fd | 5127 | |
mjr | 79:682ae3171a08 | 5128 | // figure the flash address for the config data |
mjr | 79:682ae3171a08 | 5129 | const NVM *configFlashAddr() |
mjr | 76:7f5912b6340e | 5130 | { |
mjr | 79:682ae3171a08 | 5131 | // figure the number of sectors we need, rounding up |
mjr | 79:682ae3171a08 | 5132 | int nSectors = (sizeof(NVM) + SECTOR_SIZE - 1)/SECTOR_SIZE; |
mjr | 79:682ae3171a08 | 5133 | |
mjr | 79:682ae3171a08 | 5134 | // figure the total size required from the number of sectors |
mjr | 79:682ae3171a08 | 5135 | int reservedSize = nSectors * SECTOR_SIZE; |
mjr | 79:682ae3171a08 | 5136 | |
mjr | 79:682ae3171a08 | 5137 | // locate it at the top of memory |
mjr | 79:682ae3171a08 | 5138 | uint32_t addr = iap.flashSize() - reservedSize; |
mjr | 79:682ae3171a08 | 5139 | |
mjr | 79:682ae3171a08 | 5140 | // return it as a read-only NVM pointer |
mjr | 79:682ae3171a08 | 5141 | return (const NVM *)addr; |
mjr | 35:e959ffba78fd | 5142 | } |
mjr | 35:e959ffba78fd | 5143 | |
mjr | 76:7f5912b6340e | 5144 | // Load the config from flash. Returns true if a valid non-default |
mjr | 76:7f5912b6340e | 5145 | // configuration was loaded, false if we not. If we return false, |
mjr | 76:7f5912b6340e | 5146 | // we load the factory defaults, so the configuration object is valid |
mjr | 76:7f5912b6340e | 5147 | // in either case. |
mjr | 76:7f5912b6340e | 5148 | bool loadConfigFromFlash() |
mjr | 35:e959ffba78fd | 5149 | { |
mjr | 35:e959ffba78fd | 5150 | // We want to use the KL25Z's on-board flash to store our configuration |
mjr | 35:e959ffba78fd | 5151 | // data persistently, so that we can restore it across power cycles. |
mjr | 35:e959ffba78fd | 5152 | // Unfortunatly, the mbed platform doesn't explicitly support this. |
mjr | 35:e959ffba78fd | 5153 | // mbed treats the on-board flash as a raw storage device for linker |
mjr | 35:e959ffba78fd | 5154 | // output, and assumes that the linker output is the only thing |
mjr | 35:e959ffba78fd | 5155 | // stored there. There's no file system and no allowance for shared |
mjr | 35:e959ffba78fd | 5156 | // use for other purposes. Fortunately, the linker ues the space in |
mjr | 35:e959ffba78fd | 5157 | // the obvious way, storing the entire linked program in a contiguous |
mjr | 35:e959ffba78fd | 5158 | // block starting at the lowest flash address. This means that the |
mjr | 35:e959ffba78fd | 5159 | // rest of flash - from the end of the linked program to the highest |
mjr | 35:e959ffba78fd | 5160 | // flash address - is all unused free space. Writing our data there |
mjr | 35:e959ffba78fd | 5161 | // won't conflict with anything else. Since the linker doesn't give |
mjr | 35:e959ffba78fd | 5162 | // us any programmatic access to the total linker output size, it's |
mjr | 35:e959ffba78fd | 5163 | // safest to just store our config data at the very end of the flash |
mjr | 35:e959ffba78fd | 5164 | // region (i.e., the highest address). As long as it's smaller than |
mjr | 35:e959ffba78fd | 5165 | // the free space, it won't collide with the linker area. |
mjr | 35:e959ffba78fd | 5166 | |
mjr | 35:e959ffba78fd | 5167 | // Figure how many sectors we need for our structure |
mjr | 79:682ae3171a08 | 5168 | const NVM *flash = configFlashAddr(); |
mjr | 35:e959ffba78fd | 5169 | |
mjr | 35:e959ffba78fd | 5170 | // if the flash is valid, load it; otherwise initialize to defaults |
mjr | 76:7f5912b6340e | 5171 | bool nvm_valid = flash->valid(); |
mjr | 76:7f5912b6340e | 5172 | if (nvm_valid) |
mjr | 35:e959ffba78fd | 5173 | { |
mjr | 35:e959ffba78fd | 5174 | // flash is valid - load it into the RAM copy of the structure |
mjr | 35:e959ffba78fd | 5175 | memcpy(&nvm, flash, sizeof(NVM)); |
mjr | 35:e959ffba78fd | 5176 | } |
mjr | 35:e959ffba78fd | 5177 | else |
mjr | 35:e959ffba78fd | 5178 | { |
mjr | 76:7f5912b6340e | 5179 | // flash is invalid - load factory settings into RAM structure |
mjr | 35:e959ffba78fd | 5180 | cfg.setFactoryDefaults(); |
mjr | 35:e959ffba78fd | 5181 | } |
mjr | 76:7f5912b6340e | 5182 | |
mjr | 76:7f5912b6340e | 5183 | // tell the caller what happened |
mjr | 76:7f5912b6340e | 5184 | return nvm_valid; |
mjr | 35:e959ffba78fd | 5185 | } |
mjr | 35:e959ffba78fd | 5186 | |
mjr | 86:e30a1f60f783 | 5187 | // Save the config. Returns true on success, false on failure. |
mjr | 86:e30a1f60f783 | 5188 | // 'tFollowup' is the follow-up time in seconds. If the write is |
mjr | 86:e30a1f60f783 | 5189 | // successful, we'll turn on the success flag in the status reports |
mjr | 86:e30a1f60f783 | 5190 | // and leave it on for this interval. If 'reboot' is true, we'll |
mjr | 86:e30a1f60f783 | 5191 | // also schedule a reboot at the end of the followup interval. |
mjr | 86:e30a1f60f783 | 5192 | bool saveConfigToFlash(int tFollowup, bool reboot) |
mjr | 33:d832bcab089e | 5193 | { |
mjr | 76:7f5912b6340e | 5194 | // get the config block location in the flash memory |
mjr | 77:0b96f6867312 | 5195 | uint32_t addr = uint32_t(configFlashAddr()); |
mjr | 79:682ae3171a08 | 5196 | |
mjr | 101:755f44622abc | 5197 | // save the data |
mjr | 101:755f44622abc | 5198 | bool ok = nvm.save(iap, addr); |
mjr | 101:755f44622abc | 5199 | |
mjr | 101:755f44622abc | 5200 | // if the save succeeded, do post-save work |
mjr | 101:755f44622abc | 5201 | if (ok) |
mjr | 86:e30a1f60f783 | 5202 | { |
mjr | 86:e30a1f60f783 | 5203 | // success - report the successful save in the status flags |
mjr | 86:e30a1f60f783 | 5204 | saveConfigSucceededFlag = 0x40; |
mjr | 86:e30a1f60f783 | 5205 | |
mjr | 86:e30a1f60f783 | 5206 | // start the followup timer |
mjr | 87:8d35c74403af | 5207 | saveConfigFollowupTime = tFollowup; |
mjr | 87:8d35c74403af | 5208 | saveConfigFollowupTimer.reset(); |
mjr | 86:e30a1f60f783 | 5209 | saveConfigFollowupTimer.start(); |
mjr | 86:e30a1f60f783 | 5210 | |
mjr | 86:e30a1f60f783 | 5211 | // if a reboot is pending, flag it |
mjr | 86:e30a1f60f783 | 5212 | saveConfigRebootPending = reboot; |
mjr | 86:e30a1f60f783 | 5213 | } |
mjr | 101:755f44622abc | 5214 | |
mjr | 101:755f44622abc | 5215 | // return the success indication |
mjr | 101:755f44622abc | 5216 | return ok; |
mjr | 76:7f5912b6340e | 5217 | } |
mjr | 76:7f5912b6340e | 5218 | |
mjr | 76:7f5912b6340e | 5219 | // --------------------------------------------------------------------------- |
mjr | 76:7f5912b6340e | 5220 | // |
mjr | 76:7f5912b6340e | 5221 | // Host-loaded configuration. The Flash NVM block above is designed to be |
mjr | 76:7f5912b6340e | 5222 | // stored from within the firmware; in contrast, the host-loaded config is |
mjr | 76:7f5912b6340e | 5223 | // stored by the host, by patching the firwmare binary (.bin) file before |
mjr | 76:7f5912b6340e | 5224 | // downloading it to the device. |
mjr | 76:7f5912b6340e | 5225 | // |
mjr | 100:1ff35c07217c | 5226 | // Ideally, we'd use the host-loaded memory for all configuration updates |
mjr | 100:1ff35c07217c | 5227 | // from the host - that is, any time the host wants to update config settings, |
mjr | 100:1ff35c07217c | 5228 | // such as via user input in the config tool. In the past, I wanted to do |
mjr | 100:1ff35c07217c | 5229 | // it this way because it seemed to be unreliable to write flash memory via |
mjr | 100:1ff35c07217c | 5230 | // the device. But that turned out to be due to a bug in the mbed Ticker |
mjr | 100:1ff35c07217c | 5231 | // code (of all things!), which we've fixed - since then, flash writing on |
mjr | 100:1ff35c07217c | 5232 | // the device has been bulletproof. Even so, doing host-to-device flash |
mjr | 100:1ff35c07217c | 5233 | // writing for config updates would be nice just for the sake of speed, as |
mjr | 100:1ff35c07217c | 5234 | // the alternative is that we send the variables one at a time by USB, which |
mjr | 100:1ff35c07217c | 5235 | // takes noticeable time when reprogramming the whole config set. But |
mjr | 100:1ff35c07217c | 5236 | // there's no way to accomplish a single-sector flash write via OpenSDA; you |
mjr | 100:1ff35c07217c | 5237 | // can only rewrite the entire flash memory as a unit. |
mjr | 100:1ff35c07217c | 5238 | // |
mjr | 100:1ff35c07217c | 5239 | // We can at least use this approach to do a fast configuration restore |
mjr | 100:1ff35c07217c | 5240 | // when downloading new firmware. In that case, we're rewriting all of |
mjr | 100:1ff35c07217c | 5241 | // flash memory anyway, so we might as well include the config data. |
mjr | 76:7f5912b6340e | 5242 | // |
mjr | 76:7f5912b6340e | 5243 | // The memory here is stored using the same format as the USB "Set Config |
mjr | 76:7f5912b6340e | 5244 | // Variable" command. These messages are 8 bytes long and start with a |
mjr | 76:7f5912b6340e | 5245 | // byte value 66, followed by the variable ID, followed by the variable |
mjr | 76:7f5912b6340e | 5246 | // value data in a format defined separately for each variable. To load |
mjr | 76:7f5912b6340e | 5247 | // the data, we'll start at the first byte after the signature, and |
mjr | 76:7f5912b6340e | 5248 | // interpret each 8-byte block as a type 66 message. If the first byte |
mjr | 76:7f5912b6340e | 5249 | // of a block is not 66, we'll take it as the end of the data. |
mjr | 76:7f5912b6340e | 5250 | // |
mjr | 76:7f5912b6340e | 5251 | // We provide a block of storage here big enough for 1,024 variables. |
mjr | 76:7f5912b6340e | 5252 | // The header consists of a 30-byte signature followed by two bytes giving |
mjr | 76:7f5912b6340e | 5253 | // the available space in the area, in this case 8192 == 0x0200. The |
mjr | 76:7f5912b6340e | 5254 | // length is little-endian. Note that the linker will implicitly zero |
mjr | 76:7f5912b6340e | 5255 | // the rest of the block, so if the host doesn't populate it, we'll see |
mjr | 76:7f5912b6340e | 5256 | // that it's empty by virtue of not containing the required '66' byte |
mjr | 76:7f5912b6340e | 5257 | // prefix for the first 8-byte variable block. |
mjr | 76:7f5912b6340e | 5258 | static const uint8_t hostLoadedConfig[8192+32] |
mjr | 76:7f5912b6340e | 5259 | __attribute__ ((aligned(SECTOR_SIZE))) = |
mjr | 76:7f5912b6340e | 5260 | "///Pinscape.HostLoadedConfig//\0\040"; // 30 byte signature + 2 byte length |
mjr | 76:7f5912b6340e | 5261 | |
mjr | 76:7f5912b6340e | 5262 | // Get a pointer to the first byte of the configuration data |
mjr | 76:7f5912b6340e | 5263 | const uint8_t *getHostLoadedConfigData() |
mjr | 76:7f5912b6340e | 5264 | { |
mjr | 76:7f5912b6340e | 5265 | // the first configuration variable byte immediately follows the |
mjr | 76:7f5912b6340e | 5266 | // 32-byte signature header |
mjr | 76:7f5912b6340e | 5267 | return hostLoadedConfig + 32; |
mjr | 76:7f5912b6340e | 5268 | }; |
mjr | 76:7f5912b6340e | 5269 | |
mjr | 76:7f5912b6340e | 5270 | // forward reference to config var store function |
mjr | 76:7f5912b6340e | 5271 | void configVarSet(const uint8_t *); |
mjr | 76:7f5912b6340e | 5272 | |
mjr | 76:7f5912b6340e | 5273 | // Load the host-loaded configuration data into the active (RAM) |
mjr | 76:7f5912b6340e | 5274 | // configuration object. |
mjr | 76:7f5912b6340e | 5275 | void loadHostLoadedConfig() |
mjr | 76:7f5912b6340e | 5276 | { |
mjr | 76:7f5912b6340e | 5277 | // Start at the first configuration variable. Each variable |
mjr | 76:7f5912b6340e | 5278 | // block is in the format of a Set Config Variable command in |
mjr | 76:7f5912b6340e | 5279 | // the USB protocol, so each block starts with a byte value of |
mjr | 76:7f5912b6340e | 5280 | // 66 and is 8 bytes long. Continue as long as we find valid |
mjr | 76:7f5912b6340e | 5281 | // variable blocks, or reach end end of the block. |
mjr | 76:7f5912b6340e | 5282 | const uint8_t *start = getHostLoadedConfigData(); |
mjr | 76:7f5912b6340e | 5283 | const uint8_t *end = hostLoadedConfig + sizeof(hostLoadedConfig); |
mjr | 76:7f5912b6340e | 5284 | for (const uint8_t *p = getHostLoadedConfigData() ; start < end && *p == 66 ; p += 8) |
mjr | 76:7f5912b6340e | 5285 | { |
mjr | 76:7f5912b6340e | 5286 | // load this variable |
mjr | 76:7f5912b6340e | 5287 | configVarSet(p); |
mjr | 76:7f5912b6340e | 5288 | } |
mjr | 35:e959ffba78fd | 5289 | } |
mjr | 35:e959ffba78fd | 5290 | |
mjr | 35:e959ffba78fd | 5291 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 5292 | // |
mjr | 55:4db125cd11a0 | 5293 | // Pixel dump mode - the host requested a dump of image sensor pixels |
mjr | 55:4db125cd11a0 | 5294 | // (helpful for installing and setting up the sensor and light source) |
mjr | 55:4db125cd11a0 | 5295 | // |
mjr | 55:4db125cd11a0 | 5296 | bool reportPlungerStat = false; |
mjr | 55:4db125cd11a0 | 5297 | uint8_t reportPlungerStatFlags; // plunger pixel report flag bits (see ccdSensor.h) |
mjr | 55:4db125cd11a0 | 5298 | uint8_t reportPlungerStatTime; // extra exposure time for plunger pixel report |
mjr | 101:755f44622abc | 5299 | uint8_t tReportPlungerStat; // timestamp of most recent plunger status request |
mjr | 55:4db125cd11a0 | 5300 | |
mjr | 55:4db125cd11a0 | 5301 | |
mjr | 55:4db125cd11a0 | 5302 | // --------------------------------------------------------------------------- |
mjr | 55:4db125cd11a0 | 5303 | // |
mjr | 40:cc0d9814522b | 5304 | // Night mode setting updates |
mjr | 40:cc0d9814522b | 5305 | // |
mjr | 38:091e511ce8a0 | 5306 | |
mjr | 38:091e511ce8a0 | 5307 | // Turn night mode on or off |
mjr | 38:091e511ce8a0 | 5308 | static void setNightMode(bool on) |
mjr | 38:091e511ce8a0 | 5309 | { |
mjr | 77:0b96f6867312 | 5310 | // Set the new night mode flag in the noisy output class. Note |
mjr | 77:0b96f6867312 | 5311 | // that we use the status report bit flag value 0x02 when on, so |
mjr | 77:0b96f6867312 | 5312 | // that we can just '|' this into the overall status bits. |
mjr | 77:0b96f6867312 | 5313 | nightMode = on ? 0x02 : 0x00; |
mjr | 55:4db125cd11a0 | 5314 | |
mjr | 40:cc0d9814522b | 5315 | // update the special output pin that shows the night mode state |
mjr | 53:9b2611964afc | 5316 | int port = int(cfg.nightMode.port) - 1; |
mjr | 53:9b2611964afc | 5317 | if (port >= 0 && port < numOutputs) |
mjr | 53:9b2611964afc | 5318 | lwPin[port]->set(nightMode ? 255 : 0); |
mjr | 76:7f5912b6340e | 5319 | |
mjr | 76:7f5912b6340e | 5320 | // Reset all outputs at their current value, so that the underlying |
mjr | 76:7f5912b6340e | 5321 | // physical outputs get turned on or off as appropriate for the night |
mjr | 76:7f5912b6340e | 5322 | // mode change. |
mjr | 76:7f5912b6340e | 5323 | for (int i = 0 ; i < numOutputs ; ++i) |
mjr | 76:7f5912b6340e | 5324 | lwPin[i]->set(outLevel[i]); |
mjr | 76:7f5912b6340e | 5325 | |
mjr | 76:7f5912b6340e | 5326 | // update 74HC595 outputs |
mjr | 76:7f5912b6340e | 5327 | if (hc595 != 0) |
mjr | 76:7f5912b6340e | 5328 | hc595->update(); |
mjr | 38:091e511ce8a0 | 5329 | } |
mjr | 38:091e511ce8a0 | 5330 | |
mjr | 38:091e511ce8a0 | 5331 | // Toggle night mode |
mjr | 38:091e511ce8a0 | 5332 | static void toggleNightMode() |
mjr | 38:091e511ce8a0 | 5333 | { |
mjr | 53:9b2611964afc | 5334 | setNightMode(!nightMode); |
mjr | 38:091e511ce8a0 | 5335 | } |
mjr | 38:091e511ce8a0 | 5336 | |
mjr | 38:091e511ce8a0 | 5337 | |
mjr | 38:091e511ce8a0 | 5338 | // --------------------------------------------------------------------------- |
mjr | 38:091e511ce8a0 | 5339 | // |
mjr | 35:e959ffba78fd | 5340 | // Plunger Sensor |
mjr | 35:e959ffba78fd | 5341 | // |
mjr | 35:e959ffba78fd | 5342 | |
mjr | 35:e959ffba78fd | 5343 | // the plunger sensor interface object |
mjr | 35:e959ffba78fd | 5344 | PlungerSensor *plungerSensor = 0; |
mjr | 35:e959ffba78fd | 5345 | |
mjr | 76:7f5912b6340e | 5346 | |
mjr | 35:e959ffba78fd | 5347 | // Create the plunger sensor based on the current configuration. If |
mjr | 35:e959ffba78fd | 5348 | // there's already a sensor object, we'll delete it. |
mjr | 35:e959ffba78fd | 5349 | void createPlunger() |
mjr | 35:e959ffba78fd | 5350 | { |
mjr | 35:e959ffba78fd | 5351 | // create the new sensor object according to the type |
mjr | 35:e959ffba78fd | 5352 | switch (cfg.plunger.sensorType) |
mjr | 35:e959ffba78fd | 5353 | { |
mjr | 82:4f6209cb5c33 | 5354 | case PlungerType_TSL1410R: |
mjr | 82:4f6209cb5c33 | 5355 | // TSL1410R, shadow edge detector |
mjr | 35:e959ffba78fd | 5356 | // pins are: SI, CLOCK, AO |
mjr | 53:9b2611964afc | 5357 | plungerSensor = new PlungerSensorTSL1410R( |
mjr | 53:9b2611964afc | 5358 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 53:9b2611964afc | 5359 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 82:4f6209cb5c33 | 5360 | wirePinName(cfg.plunger.sensorPin[2])); |
mjr | 35:e959ffba78fd | 5361 | break; |
mjr | 35:e959ffba78fd | 5362 | |
mjr | 82:4f6209cb5c33 | 5363 | case PlungerType_TSL1412S: |
mjr | 82:4f6209cb5c33 | 5364 | // TSL1412S, shadow edge detector |
mjr | 82:4f6209cb5c33 | 5365 | // pins are: SI, CLOCK, AO |
mjr | 53:9b2611964afc | 5366 | plungerSensor = new PlungerSensorTSL1412R( |
mjr | 53:9b2611964afc | 5367 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 53:9b2611964afc | 5368 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 82:4f6209cb5c33 | 5369 | wirePinName(cfg.plunger.sensorPin[2])); |
mjr | 35:e959ffba78fd | 5370 | break; |
mjr | 35:e959ffba78fd | 5371 | |
mjr | 35:e959ffba78fd | 5372 | case PlungerType_Pot: |
mjr | 82:4f6209cb5c33 | 5373 | // Potentiometer (or any other sensor with a linear analog voltage |
mjr | 82:4f6209cb5c33 | 5374 | // reading as the proxy for the position) |
mjr | 82:4f6209cb5c33 | 5375 | // pins are: AO (analog in) |
mjr | 53:9b2611964afc | 5376 | plungerSensor = new PlungerSensorPot( |
mjr | 53:9b2611964afc | 5377 | wirePinName(cfg.plunger.sensorPin[0])); |
mjr | 35:e959ffba78fd | 5378 | break; |
mjr | 82:4f6209cb5c33 | 5379 | |
mjr | 82:4f6209cb5c33 | 5380 | case PlungerType_OptQuad: |
mjr | 82:4f6209cb5c33 | 5381 | // Optical quadrature sensor, AEDR8300-K or similar. The -K is |
mjr | 82:4f6209cb5c33 | 5382 | // designed for a 75 LPI scale, which translates to 300 pulses/inch. |
mjr | 82:4f6209cb5c33 | 5383 | // Pins are: CHA, CHB (quadrature pulse inputs). |
mjr | 82:4f6209cb5c33 | 5384 | plungerSensor = new PlungerSensorQuad( |
mjr | 82:4f6209cb5c33 | 5385 | 300, |
mjr | 82:4f6209cb5c33 | 5386 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 82:4f6209cb5c33 | 5387 | wirePinName(cfg.plunger.sensorPin[1])); |
mjr | 82:4f6209cb5c33 | 5388 | break; |
mjr | 82:4f6209cb5c33 | 5389 | |
mjr | 82:4f6209cb5c33 | 5390 | case PlungerType_TSL1401CL: |
mjr | 82:4f6209cb5c33 | 5391 | // TSL1401CL, absolute position encoder with bar code scale |
mjr | 82:4f6209cb5c33 | 5392 | // pins are: SI, CLOCK, AO |
mjr | 82:4f6209cb5c33 | 5393 | plungerSensor = new PlungerSensorTSL1401CL( |
mjr | 82:4f6209cb5c33 | 5394 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 82:4f6209cb5c33 | 5395 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 82:4f6209cb5c33 | 5396 | wirePinName(cfg.plunger.sensorPin[2])); |
mjr | 82:4f6209cb5c33 | 5397 | break; |
mjr | 82:4f6209cb5c33 | 5398 | |
mjr | 82:4f6209cb5c33 | 5399 | case PlungerType_VL6180X: |
mjr | 82:4f6209cb5c33 | 5400 | // VL6180X time-of-flight IR distance sensor |
mjr | 111:42dc75fbe623 | 5401 | // pins are: SDA, SCL, GPIO0/CE |
mjr | 82:4f6209cb5c33 | 5402 | plungerSensor = new PlungerSensorVL6180X( |
mjr | 82:4f6209cb5c33 | 5403 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 82:4f6209cb5c33 | 5404 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 82:4f6209cb5c33 | 5405 | wirePinName(cfg.plunger.sensorPin[2])); |
mjr | 82:4f6209cb5c33 | 5406 | break; |
mjr | 82:4f6209cb5c33 | 5407 | |
mjr | 100:1ff35c07217c | 5408 | case PlungerType_AEAT6012: |
mjr | 100:1ff35c07217c | 5409 | // Broadcom AEAT-6012-A06 magnetic rotary encoder |
mjr | 100:1ff35c07217c | 5410 | // pins are: CS (chip select, dig out), CLK (dig out), DO (data, dig in) |
mjr | 100:1ff35c07217c | 5411 | plungerSensor = new PlungerSensorAEAT601X<12>( |
mjr | 100:1ff35c07217c | 5412 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 100:1ff35c07217c | 5413 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 100:1ff35c07217c | 5414 | wirePinName(cfg.plunger.sensorPin[2])); |
mjr | 100:1ff35c07217c | 5415 | break; |
mjr | 100:1ff35c07217c | 5416 | |
mjr | 100:1ff35c07217c | 5417 | case PlungerType_TCD1103: |
mjr | 100:1ff35c07217c | 5418 | // Toshiba TCD1103GFG linear CCD, optical edge detection, with |
mjr | 100:1ff35c07217c | 5419 | // inverted logic gates. |
mjr | 100:1ff35c07217c | 5420 | // Pins are: fM (master clock, PWM), OS (sample data, analog in), |
mjr | 100:1ff35c07217c | 5421 | // ICG (integration clear gate, dig out), SH (shift gate, dig out) |
mjr | 100:1ff35c07217c | 5422 | plungerSensor = new PlungerSensorTCD1103<true>( |
mjr | 100:1ff35c07217c | 5423 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 100:1ff35c07217c | 5424 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 100:1ff35c07217c | 5425 | wirePinName(cfg.plunger.sensorPin[2]), |
mjr | 100:1ff35c07217c | 5426 | wirePinName(cfg.plunger.sensorPin[3])); |
mjr | 100:1ff35c07217c | 5427 | break; |
mjr | 100:1ff35c07217c | 5428 | |
mjr | 111:42dc75fbe623 | 5429 | case PlungerType_VCNL4010: |
mjr | 111:42dc75fbe623 | 5430 | // VCNL4010 IR proximity sensor pins are: SDA, SCL |
mjr | 111:42dc75fbe623 | 5431 | plungerSensor = new PlungerSensorVCNL4010( |
mjr | 111:42dc75fbe623 | 5432 | wirePinName(cfg.plunger.sensorPin[0]), |
mjr | 113:7330439f2ffc | 5433 | wirePinName(cfg.plunger.sensorPin[1]), |
mjr | 113:7330439f2ffc | 5434 | cfg.plunger.param1); |
mjr | 111:42dc75fbe623 | 5435 | break; |
mjr | 111:42dc75fbe623 | 5436 | |
mjr | 35:e959ffba78fd | 5437 | case PlungerType_None: |
mjr | 35:e959ffba78fd | 5438 | default: |
mjr | 35:e959ffba78fd | 5439 | plungerSensor = new PlungerSensorNull(); |
mjr | 35:e959ffba78fd | 5440 | break; |
mjr | 35:e959ffba78fd | 5441 | } |
mjr | 100:1ff35c07217c | 5442 | |
mjr | 100:1ff35c07217c | 5443 | // initialize the plunger from the saved configuration |
mjr | 100:1ff35c07217c | 5444 | plungerSensor->restoreCalibration(cfg); |
mjr | 86:e30a1f60f783 | 5445 | |
mjr | 87:8d35c74403af | 5446 | // initialize the config variables affecting the plunger |
mjr | 87:8d35c74403af | 5447 | plungerSensor->onConfigChange(19, cfg); |
mjr | 87:8d35c74403af | 5448 | plungerSensor->onConfigChange(20, cfg); |
mjr | 33:d832bcab089e | 5449 | } |
mjr | 33:d832bcab089e | 5450 | |
mjr | 52:8298b2a73eb2 | 5451 | // Global plunger calibration mode flag |
mjr | 52:8298b2a73eb2 | 5452 | bool plungerCalMode; |
mjr | 52:8298b2a73eb2 | 5453 | |
mjr | 48:058ace2aed1d | 5454 | // Plunger reader |
mjr | 51:57eb311faafa | 5455 | // |
mjr | 51:57eb311faafa | 5456 | // This class encapsulates our plunger data processing. At the simplest |
mjr | 51:57eb311faafa | 5457 | // level, we read the position from the sensor, adjust it for the |
mjr | 51:57eb311faafa | 5458 | // calibration settings, and report the calibrated position to the host. |
mjr | 51:57eb311faafa | 5459 | // |
mjr | 51:57eb311faafa | 5460 | // In addition, we constantly monitor the data for "firing" motions. |
mjr | 51:57eb311faafa | 5461 | // A firing motion is when the user pulls back the plunger and releases |
mjr | 51:57eb311faafa | 5462 | // it, allowing it to shoot forward under the force of the main spring. |
mjr | 51:57eb311faafa | 5463 | // When we detect that this is happening, we briefly stop reporting the |
mjr | 51:57eb311faafa | 5464 | // real physical position that we're reading from the sensor, and instead |
mjr | 51:57eb311faafa | 5465 | // report a synthetic series of positions that depicts an idealized |
mjr | 51:57eb311faafa | 5466 | // firing motion. |
mjr | 51:57eb311faafa | 5467 | // |
mjr | 51:57eb311faafa | 5468 | // The point of the synthetic reports is to correct for distortions |
mjr | 51:57eb311faafa | 5469 | // created by the joystick interface conventions used by VP and other |
mjr | 51:57eb311faafa | 5470 | // PC pinball emulators. The convention they use is simply to have the |
mjr | 51:57eb311faafa | 5471 | // plunger device report the instantaneous position of the real plunger. |
mjr | 51:57eb311faafa | 5472 | // The PC software polls this reported position periodically, and moves |
mjr | 51:57eb311faafa | 5473 | // the on-screen virtual plunger in sync with the real plunger. This |
mjr | 51:57eb311faafa | 5474 | // works fine for human-scale motion when the user is manually moving |
mjr | 51:57eb311faafa | 5475 | // the plunger. But it doesn't work for the high speed motion of a |
mjr | 51:57eb311faafa | 5476 | // release. The plunger simply moves too fast. VP polls in about 10ms |
mjr | 51:57eb311faafa | 5477 | // intervals; the plunger takes about 50ms to travel from fully |
mjr | 51:57eb311faafa | 5478 | // retracted to the park position when released. The low sampling |
mjr | 51:57eb311faafa | 5479 | // rate relative to the rate of change of the sampled data creates |
mjr | 51:57eb311faafa | 5480 | // a classic digital aliasing effect. |
mjr | 51:57eb311faafa | 5481 | // |
mjr | 51:57eb311faafa | 5482 | // The synthetic reporting scheme compensates for the interface |
mjr | 51:57eb311faafa | 5483 | // distortions by essentially changing to a coarse enough timescale |
mjr | 51:57eb311faafa | 5484 | // that VP can reliably interpret the readings. Conceptually, there |
mjr | 51:57eb311faafa | 5485 | // are three steps involved in doing this. First, we analyze the |
mjr | 51:57eb311faafa | 5486 | // actual sensor data to detect and characterize the release motion. |
mjr | 51:57eb311faafa | 5487 | // Second, once we think we have a release in progress, we fit the |
mjr | 51:57eb311faafa | 5488 | // data to a mathematical model of the release. The model we use is |
mjr | 51:57eb311faafa | 5489 | // dead simple: we consider the release to have one parameter, namely |
mjr | 51:57eb311faafa | 5490 | // the retraction distance at the moment the user lets go. This is an |
mjr | 51:57eb311faafa | 5491 | // excellent proxy in the real physical system for the final speed |
mjr | 51:57eb311faafa | 5492 | // when the plunger hits the ball, and it also happens to match how |
mjr | 51:57eb311faafa | 5493 | // VP models it internally. Third, we construct synthetic reports |
mjr | 51:57eb311faafa | 5494 | // that will make VP's internal state match our model. This is also |
mjr | 51:57eb311faafa | 5495 | // pretty simple: we just need to send VP the maximum retraction |
mjr | 51:57eb311faafa | 5496 | // distance for long enough to be sure that it polls it at least |
mjr | 51:57eb311faafa | 5497 | // once, and then send it the park position for long enough to |
mjr | 51:57eb311faafa | 5498 | // ensure that VP will complete the same firing motion. The |
mjr | 51:57eb311faafa | 5499 | // immediate jump from the maximum point to the zero point will |
mjr | 51:57eb311faafa | 5500 | // cause VP to move its simulation model plunger forward from the |
mjr | 51:57eb311faafa | 5501 | // starting point at its natural spring acceleration rate, which |
mjr | 51:57eb311faafa | 5502 | // is exactly what the real plunger just did. |
mjr | 51:57eb311faafa | 5503 | // |
mjr | 48:058ace2aed1d | 5504 | class PlungerReader |
mjr | 48:058ace2aed1d | 5505 | { |
mjr | 48:058ace2aed1d | 5506 | public: |
mjr | 48:058ace2aed1d | 5507 | PlungerReader() |
mjr | 48:058ace2aed1d | 5508 | { |
mjr | 48:058ace2aed1d | 5509 | // not in a firing event yet |
mjr | 48:058ace2aed1d | 5510 | firing = 0; |
mjr | 48:058ace2aed1d | 5511 | } |
mjr | 76:7f5912b6340e | 5512 | |
mjr | 48:058ace2aed1d | 5513 | // Collect a reading from the plunger sensor. The main loop calls |
mjr | 48:058ace2aed1d | 5514 | // this frequently to read the current raw position data from the |
mjr | 48:058ace2aed1d | 5515 | // sensor. We analyze the raw data to produce the calibrated |
mjr | 48:058ace2aed1d | 5516 | // position that we report to the PC via the joystick interface. |
mjr | 48:058ace2aed1d | 5517 | void read() |
mjr | 48:058ace2aed1d | 5518 | { |
mjr | 76:7f5912b6340e | 5519 | // if the sensor is busy, skip the reading on this round |
mjr | 76:7f5912b6340e | 5520 | if (!plungerSensor->ready()) |
mjr | 76:7f5912b6340e | 5521 | return; |
mjr | 76:7f5912b6340e | 5522 | |
mjr | 48:058ace2aed1d | 5523 | // Read a sample from the sensor |
mjr | 48:058ace2aed1d | 5524 | PlungerReading r; |
mjr | 48:058ace2aed1d | 5525 | if (plungerSensor->read(r)) |
mjr | 48:058ace2aed1d | 5526 | { |
mjr | 53:9b2611964afc | 5527 | // check for calibration mode |
mjr | 53:9b2611964afc | 5528 | if (plungerCalMode) |
mjr | 53:9b2611964afc | 5529 | { |
mjr | 53:9b2611964afc | 5530 | // Calibration mode. Adjust the calibration bounds to fit |
mjr | 53:9b2611964afc | 5531 | // the value. If this value is beyond the current min or max, |
mjr | 53:9b2611964afc | 5532 | // expand the envelope to include this new value. |
mjr | 53:9b2611964afc | 5533 | if (r.pos > cfg.plunger.cal.max) |
mjr | 53:9b2611964afc | 5534 | cfg.plunger.cal.max = r.pos; |
mjr | 53:9b2611964afc | 5535 | if (r.pos < cfg.plunger.cal.min) |
mjr | 53:9b2611964afc | 5536 | cfg.plunger.cal.min = r.pos; |
mjr | 76:7f5912b6340e | 5537 | |
mjr | 76:7f5912b6340e | 5538 | // update our cached calibration data |
mjr | 76:7f5912b6340e | 5539 | onUpdateCal(); |
mjr | 50:40015764bbe6 | 5540 | |
mjr | 53:9b2611964afc | 5541 | // If we're in calibration state 0, we're waiting for the |
mjr | 53:9b2611964afc | 5542 | // plunger to come to rest at the park position so that we |
mjr | 53:9b2611964afc | 5543 | // can take a sample of the park position. Check to see if |
mjr | 53:9b2611964afc | 5544 | // we've been at rest for a minimum interval. |
mjr | 53:9b2611964afc | 5545 | if (calState == 0) |
mjr | 53:9b2611964afc | 5546 | { |
mjr | 53:9b2611964afc | 5547 | if (abs(r.pos - calZeroStart.pos) < 65535/3/50) |
mjr | 53:9b2611964afc | 5548 | { |
mjr | 53:9b2611964afc | 5549 | // we're close enough - make sure we've been here long enough |
mjr | 53:9b2611964afc | 5550 | if (uint32_t(r.t - calZeroStart.t) > 100000UL) |
mjr | 53:9b2611964afc | 5551 | { |
mjr | 53:9b2611964afc | 5552 | // we've been at rest long enough - count it |
mjr | 53:9b2611964afc | 5553 | calZeroPosSum += r.pos; |
mjr | 53:9b2611964afc | 5554 | calZeroPosN += 1; |
mjr | 53:9b2611964afc | 5555 | |
mjr | 53:9b2611964afc | 5556 | // update the zero position from the new average |
mjr | 53:9b2611964afc | 5557 | cfg.plunger.cal.zero = uint16_t(calZeroPosSum / calZeroPosN); |
mjr | 76:7f5912b6340e | 5558 | onUpdateCal(); |
mjr | 53:9b2611964afc | 5559 | |
mjr | 53:9b2611964afc | 5560 | // switch to calibration state 1 - at rest |
mjr | 53:9b2611964afc | 5561 | calState = 1; |
mjr | 53:9b2611964afc | 5562 | } |
mjr | 53:9b2611964afc | 5563 | } |
mjr | 53:9b2611964afc | 5564 | else |
mjr | 53:9b2611964afc | 5565 | { |
mjr | 53:9b2611964afc | 5566 | // we're not close to the last position - start again here |
mjr | 53:9b2611964afc | 5567 | calZeroStart = r; |
mjr | 53:9b2611964afc | 5568 | } |
mjr | 53:9b2611964afc | 5569 | } |
mjr | 53:9b2611964afc | 5570 | |
mjr | 53:9b2611964afc | 5571 | // Rescale to the joystick range, and adjust for the current |
mjr | 53:9b2611964afc | 5572 | // park position, but don't calibrate. We don't know the maximum |
mjr | 53:9b2611964afc | 5573 | // point yet, so we can't calibrate the range. |
mjr | 53:9b2611964afc | 5574 | r.pos = int( |
mjr | 53:9b2611964afc | 5575 | (long(r.pos - cfg.plunger.cal.zero) * JOYMAX) |
mjr | 53:9b2611964afc | 5576 | / (65535 - cfg.plunger.cal.zero)); |
mjr | 53:9b2611964afc | 5577 | } |
mjr | 53:9b2611964afc | 5578 | else |
mjr | 53:9b2611964afc | 5579 | { |
mjr | 53:9b2611964afc | 5580 | // Not in calibration mode. Apply the existing calibration and |
mjr | 53:9b2611964afc | 5581 | // rescale to the joystick range. |
mjr | 76:7f5912b6340e | 5582 | r.pos = applyCal(r.pos); |
mjr | 53:9b2611964afc | 5583 | |
mjr | 53:9b2611964afc | 5584 | // limit the result to the valid joystick range |
mjr | 53:9b2611964afc | 5585 | if (r.pos > JOYMAX) |
mjr | 53:9b2611964afc | 5586 | r.pos = JOYMAX; |
mjr | 53:9b2611964afc | 5587 | else if (r.pos < -JOYMAX) |
mjr | 53:9b2611964afc | 5588 | r.pos = -JOYMAX; |
mjr | 53:9b2611964afc | 5589 | } |
mjr | 50:40015764bbe6 | 5590 | |
mjr | 87:8d35c74403af | 5591 | // Look for a firing event - the user releasing the plunger and |
mjr | 87:8d35c74403af | 5592 | // allowing it to shoot forward at full speed. Wait at least 5ms |
mjr | 87:8d35c74403af | 5593 | // between samples for this, to help distinguish random motion |
mjr | 87:8d35c74403af | 5594 | // from the rapid motion of a firing event. |
mjr | 50:40015764bbe6 | 5595 | // |
mjr | 87:8d35c74403af | 5596 | // There's a trade-off in the choice of minimum sampling interval. |
mjr | 87:8d35c74403af | 5597 | // The longer we wait, the more certain we can be of the trend. |
mjr | 87:8d35c74403af | 5598 | // But if we wait too long, the user will perceive a delay. We |
mjr | 87:8d35c74403af | 5599 | // also want to sample frequently enough to see the release motion |
mjr | 87:8d35c74403af | 5600 | // at intermediate steps along the way, so the sampling has to be |
mjr | 87:8d35c74403af | 5601 | // considerably faster than the whole travel time, which is about |
mjr | 87:8d35c74403af | 5602 | // 25-50ms. |
mjr | 87:8d35c74403af | 5603 | if (uint32_t(r.t - prv.t) < 5000UL) |
mjr | 87:8d35c74403af | 5604 | return; |
mjr | 87:8d35c74403af | 5605 | |
mjr | 87:8d35c74403af | 5606 | // assume that we'll report this reading as-is |
mjr | 87:8d35c74403af | 5607 | z = r.pos; |
mjr | 87:8d35c74403af | 5608 | |
mjr | 87:8d35c74403af | 5609 | // Firing event detection. |
mjr | 87:8d35c74403af | 5610 | // |
mjr | 87:8d35c74403af | 5611 | // A "firing event" is when the player releases the plunger from |
mjr | 87:8d35c74403af | 5612 | // a retracted position, allowing it to shoot forward under the |
mjr | 87:8d35c74403af | 5613 | // spring tension. |
mjr | 50:40015764bbe6 | 5614 | // |
mjr | 87:8d35c74403af | 5615 | // We monitor the plunger motion for these events, and when they |
mjr | 87:8d35c74403af | 5616 | // occur, we report an "idealized" version of the motion to the |
mjr | 87:8d35c74403af | 5617 | // PC. The idealized version consists of a series of readings |
mjr | 87:8d35c74403af | 5618 | // frozen at the fully retracted position for the whole duration |
mjr | 87:8d35c74403af | 5619 | // of the forward travel, followed by a series of readings at the |
mjr | 87:8d35c74403af | 5620 | // fully forward position for long enough for the plunger to come |
mjr | 87:8d35c74403af | 5621 | // mostly to rest. The series of frozen readings aren't meant to |
mjr | 87:8d35c74403af | 5622 | // be perceptible to the player - we try to keep them short enough |
mjr | 87:8d35c74403af | 5623 | // that they're not apparent as delay. Instead, they're for the |
mjr | 87:8d35c74403af | 5624 | // PC client software's benefit. PC joystick clients use polling, |
mjr | 87:8d35c74403af | 5625 | // so they only see an unpredictable subset of the readings we |
mjr | 87:8d35c74403af | 5626 | // send. The only way to be sure that the client sees a particular |
mjr | 87:8d35c74403af | 5627 | // reading is to hold it for long enough that the client is sure to |
mjr | 87:8d35c74403af | 5628 | // poll within the hold interval. In the case of the plunger |
mjr | 87:8d35c74403af | 5629 | // firing motion, it's important that the client sees the *ends* |
mjr | 87:8d35c74403af | 5630 | // of the travel - the fully retracted starting position in |
mjr | 87:8d35c74403af | 5631 | // particular. If the PC client only polls for a sample while the |
mjr | 87:8d35c74403af | 5632 | // plunger is somewhere in the middle of the travel, the PC will |
mjr | 87:8d35c74403af | 5633 | // think that the firing motion *started* in that middle position, |
mjr | 87:8d35c74403af | 5634 | // so it won't be able to model the right amount of momentum when |
mjr | 87:8d35c74403af | 5635 | // the plunger hits the ball. We try to ensure that the PC sees |
mjr | 87:8d35c74403af | 5636 | // the right starting point by reporting the starting point for |
mjr | 87:8d35c74403af | 5637 | // extra time during the forward motion. By the same token, we |
mjr | 87:8d35c74403af | 5638 | // want the PC to know that the plunger has moved all the way |
mjr | 87:8d35c74403af | 5639 | // forward, rather than mistakenly thinking that it stopped |
mjr | 87:8d35c74403af | 5640 | // somewhere in the middle of the travel, so we freeze at the |
mjr | 87:8d35c74403af | 5641 | // forward position for a short time. |
mjr | 76:7f5912b6340e | 5642 | // |
mjr | 87:8d35c74403af | 5643 | // To detect a firing event, we look for forward motion that's |
mjr | 87:8d35c74403af | 5644 | // fast enough to be a firing event. To determine how fast is |
mjr | 87:8d35c74403af | 5645 | // fast enough, we use a simple model of the plunger motion where |
mjr | 87:8d35c74403af | 5646 | // the acceleration is constant. This is only an approximation, |
mjr | 87:8d35c74403af | 5647 | // as the spring force actually varies with spring's compression, |
mjr | 87:8d35c74403af | 5648 | // but it's close enough for our purposes here. |
mjr | 87:8d35c74403af | 5649 | // |
mjr | 87:8d35c74403af | 5650 | // Do calculations in fixed-point 2^48 scale with 64-bit ints. |
mjr | 87:8d35c74403af | 5651 | // acc2 = acceleration/2 for 50ms release time, units of unit |
mjr | 87:8d35c74403af | 5652 | // distances per microsecond squared, where the unit distance |
mjr | 87:8d35c74403af | 5653 | // is the overall travel from the starting retracted position |
mjr | 87:8d35c74403af | 5654 | // to the park position. |
mjr | 87:8d35c74403af | 5655 | const int32_t acc2 = 112590; // 2^48 scale |
mjr | 50:40015764bbe6 | 5656 | switch (firing) |
mjr | 50:40015764bbe6 | 5657 | { |
mjr | 50:40015764bbe6 | 5658 | case 0: |
mjr | 87:8d35c74403af | 5659 | // Not in firing mode. If we're retracted a bit, and the |
mjr | 87:8d35c74403af | 5660 | // motion is forward at a fast enough rate to look like a |
mjr | 87:8d35c74403af | 5661 | // release, enter firing mode. |
mjr | 87:8d35c74403af | 5662 | if (r.pos > JOYMAX/6) |
mjr | 50:40015764bbe6 | 5663 | { |
mjr | 87:8d35c74403af | 5664 | const uint32_t dt = uint32_t(r.t - prv.t); |
mjr | 87:8d35c74403af | 5665 | const uint32_t dt2 = dt*dt; // dt^2 |
mjr | 87:8d35c74403af | 5666 | if (r.pos < prv.pos - int((prv.pos*acc2*uint64_t(dt2)) >> 48)) |
mjr | 87:8d35c74403af | 5667 | { |
mjr | 87:8d35c74403af | 5668 | // Tentatively enter firing mode. Use the prior reading |
mjr | 87:8d35c74403af | 5669 | // as the starting point, and freeze reports for now. |
mjr | 87:8d35c74403af | 5670 | firingMode(1); |
mjr | 87:8d35c74403af | 5671 | f0 = prv; |
mjr | 87:8d35c74403af | 5672 | z = f0.pos; |
mjr | 87:8d35c74403af | 5673 | |
mjr | 87:8d35c74403af | 5674 | // if in calibration state 1 (at rest), switch to |
mjr | 87:8d35c74403af | 5675 | // state 2 (not at rest) |
mjr | 87:8d35c74403af | 5676 | if (calState == 1) |
mjr | 87:8d35c74403af | 5677 | calState = 2; |
mjr | 87:8d35c74403af | 5678 | } |
mjr | 50:40015764bbe6 | 5679 | } |
mjr | 50:40015764bbe6 | 5680 | break; |
mjr | 50:40015764bbe6 | 5681 | |
mjr | 50:40015764bbe6 | 5682 | case 1: |
mjr | 87:8d35c74403af | 5683 | // Tentative firing mode: the plunger was moving forward |
mjr | 87:8d35c74403af | 5684 | // at last check. To stay in firing mode, the plunger has |
mjr | 87:8d35c74403af | 5685 | // to keep moving forward fast enough to look like it's |
mjr | 87:8d35c74403af | 5686 | // moving under spring force. To figure out how fast is |
mjr | 87:8d35c74403af | 5687 | // fast enough, we use a simple model where the acceleration |
mjr | 87:8d35c74403af | 5688 | // is constant over the whole travel distance and the total |
mjr | 87:8d35c74403af | 5689 | // travel time is 50ms. The acceleration actually varies |
mjr | 87:8d35c74403af | 5690 | // slightly since it comes from the spring force, which |
mjr | 87:8d35c74403af | 5691 | // is linear in the displacement; but the plunger spring is |
mjr | 87:8d35c74403af | 5692 | // fairly compressed even when the plunger is all the way |
mjr | 87:8d35c74403af | 5693 | // forward, so the difference in tension from one end of |
mjr | 87:8d35c74403af | 5694 | // the travel to the other is fairly small, so it's not too |
mjr | 87:8d35c74403af | 5695 | // far off to model it as constant. And the real travel |
mjr | 87:8d35c74403af | 5696 | // time obviously isn't a constant, but all we need for |
mjr | 87:8d35c74403af | 5697 | // that is an upper bound. So: we'll figure the time since |
mjr | 87:8d35c74403af | 5698 | // we entered firing mode, and figure the distance we should |
mjr | 87:8d35c74403af | 5699 | // have traveled to complete the trip within the maximum |
mjr | 87:8d35c74403af | 5700 | // time allowed. If we've moved far enough, we'll stay |
mjr | 87:8d35c74403af | 5701 | // in firing mode; if not, we'll exit firing mode. And if |
mjr | 87:8d35c74403af | 5702 | // we cross the finish line while still in firing mode, |
mjr | 87:8d35c74403af | 5703 | // we'll switch to the next phase of the firing event. |
mjr | 50:40015764bbe6 | 5704 | if (r.pos <= 0) |
mjr | 50:40015764bbe6 | 5705 | { |
mjr | 87:8d35c74403af | 5706 | // We crossed the park position. Switch to the second |
mjr | 87:8d35c74403af | 5707 | // phase of the firing event, where we hold the reported |
mjr | 87:8d35c74403af | 5708 | // position at the "bounce" position (where the plunger |
mjr | 87:8d35c74403af | 5709 | // is all the way forward, compressing the barrel spring). |
mjr | 87:8d35c74403af | 5710 | // We'll stick here long enough to ensure that the PC |
mjr | 87:8d35c74403af | 5711 | // client (Visual Pinball or whatever) sees the reading |
mjr | 87:8d35c74403af | 5712 | // and processes the release motion via the simulated |
mjr | 87:8d35c74403af | 5713 | // physics. |
mjr | 50:40015764bbe6 | 5714 | firingMode(2); |
mjr | 53:9b2611964afc | 5715 | |
mjr | 53:9b2611964afc | 5716 | // if in calibration mode, and we're in state 2 (moving), |
mjr | 53:9b2611964afc | 5717 | // collect firing statistics for calibration purposes |
mjr | 53:9b2611964afc | 5718 | if (plungerCalMode && calState == 2) |
mjr | 53:9b2611964afc | 5719 | { |
mjr | 53:9b2611964afc | 5720 | // collect a new zero point for the average when we |
mjr | 53:9b2611964afc | 5721 | // come to rest |
mjr | 53:9b2611964afc | 5722 | calState = 0; |
mjr | 53:9b2611964afc | 5723 | |
mjr | 87:8d35c74403af | 5724 | // collect average firing time statistics in millseconds, |
mjr | 87:8d35c74403af | 5725 | // if it's in range (20 to 255 ms) |
mjr | 87:8d35c74403af | 5726 | const int dt = uint32_t(r.t - f0.t)/1000UL; |
mjr | 87:8d35c74403af | 5727 | if (dt >= 15 && dt <= 255) |
mjr | 53:9b2611964afc | 5728 | { |
mjr | 53:9b2611964afc | 5729 | calRlsTimeSum += dt; |
mjr | 53:9b2611964afc | 5730 | calRlsTimeN += 1; |
mjr | 53:9b2611964afc | 5731 | cfg.plunger.cal.tRelease = uint8_t(calRlsTimeSum / calRlsTimeN); |
mjr | 53:9b2611964afc | 5732 | } |
mjr | 53:9b2611964afc | 5733 | } |
mjr | 87:8d35c74403af | 5734 | |
mjr | 87:8d35c74403af | 5735 | // Figure the "bounce" position as forward of the park |
mjr | 87:8d35c74403af | 5736 | // position by 1/6 of the starting retraction distance. |
mjr | 87:8d35c74403af | 5737 | // This simulates the momentum of the plunger compressing |
mjr | 87:8d35c74403af | 5738 | // the barrel spring on the rebound. The barrel spring |
mjr | 87:8d35c74403af | 5739 | // can compress by about 1/6 of the maximum retraction |
mjr | 87:8d35c74403af | 5740 | // distance, so we'll simply treat its compression as |
mjr | 87:8d35c74403af | 5741 | // proportional to the retraction. (It might be more |
mjr | 87:8d35c74403af | 5742 | // realistic to use a slightly higher value here, maybe |
mjr | 87:8d35c74403af | 5743 | // 1/4 or 1/3 or the retraction distance, capping it at |
mjr | 87:8d35c74403af | 5744 | // a maximum of 1/6, because the real plunger probably |
mjr | 87:8d35c74403af | 5745 | // compresses the barrel spring by 100% with less than |
mjr | 87:8d35c74403af | 5746 | // 100% retraction. But that won't affect the physics |
mjr | 87:8d35c74403af | 5747 | // meaningfully, just the animation, and the effect is |
mjr | 87:8d35c74403af | 5748 | // small in any case.) |
mjr | 87:8d35c74403af | 5749 | z = f0.pos = -f0.pos / 6; |
mjr | 87:8d35c74403af | 5750 | |
mjr | 87:8d35c74403af | 5751 | // reset the starting time for this phase |
mjr | 87:8d35c74403af | 5752 | f0.t = r.t; |
mjr | 50:40015764bbe6 | 5753 | } |
mjr | 50:40015764bbe6 | 5754 | else |
mjr | 50:40015764bbe6 | 5755 | { |
mjr | 87:8d35c74403af | 5756 | // check for motion since the start of the firing event |
mjr | 87:8d35c74403af | 5757 | const uint32_t dt = uint32_t(r.t - f0.t); |
mjr | 87:8d35c74403af | 5758 | const uint32_t dt2 = dt*dt; // dt^2 |
mjr | 87:8d35c74403af | 5759 | if (dt < 50000 |
mjr | 87:8d35c74403af | 5760 | && r.pos < f0.pos - int((f0.pos*acc2*uint64_t(dt2)) >> 48)) |
mjr | 87:8d35c74403af | 5761 | { |
mjr | 87:8d35c74403af | 5762 | // It's moving fast enough to still be in a release |
mjr | 87:8d35c74403af | 5763 | // motion. Continue reporting the start position, and |
mjr | 87:8d35c74403af | 5764 | // stay in the first release phase. |
mjr | 87:8d35c74403af | 5765 | z = f0.pos; |
mjr | 87:8d35c74403af | 5766 | } |
mjr | 87:8d35c74403af | 5767 | else |
mjr | 87:8d35c74403af | 5768 | { |
mjr | 87:8d35c74403af | 5769 | // It's not moving fast enough to be a release |
mjr | 87:8d35c74403af | 5770 | // motion. Return to the default state. |
mjr | 87:8d35c74403af | 5771 | firingMode(0); |
mjr | 87:8d35c74403af | 5772 | calState = 1; |
mjr | 87:8d35c74403af | 5773 | } |
mjr | 50:40015764bbe6 | 5774 | } |
mjr | 50:40015764bbe6 | 5775 | break; |
mjr | 50:40015764bbe6 | 5776 | |
mjr | 50:40015764bbe6 | 5777 | case 2: |
mjr | 87:8d35c74403af | 5778 | // Firing mode, holding at forward compression position. |
mjr | 87:8d35c74403af | 5779 | // Hold here for 25ms. |
mjr | 87:8d35c74403af | 5780 | if (uint32_t(r.t - f0.t) < 25000) |
mjr | 50:40015764bbe6 | 5781 | { |
mjr | 87:8d35c74403af | 5782 | // stay here for now |
mjr | 87:8d35c74403af | 5783 | z = f0.pos; |
mjr | 50:40015764bbe6 | 5784 | } |
mjr | 50:40015764bbe6 | 5785 | else |
mjr | 50:40015764bbe6 | 5786 | { |
mjr | 87:8d35c74403af | 5787 | // advance to the next phase, where we report the park |
mjr | 87:8d35c74403af | 5788 | // position until the plunger comes to rest |
mjr | 50:40015764bbe6 | 5789 | firingMode(3); |
mjr | 50:40015764bbe6 | 5790 | z = 0; |
mjr | 87:8d35c74403af | 5791 | |
mjr | 87:8d35c74403af | 5792 | // remember when we started |
mjr | 87:8d35c74403af | 5793 | f0.t = r.t; |
mjr | 50:40015764bbe6 | 5794 | } |
mjr | 50:40015764bbe6 | 5795 | break; |
mjr | 50:40015764bbe6 | 5796 | |
mjr | 50:40015764bbe6 | 5797 | case 3: |
mjr | 87:8d35c74403af | 5798 | // Firing event, holding at park position. Stay here for |
mjr | 87:8d35c74403af | 5799 | // a few moments so that the PC client can simulate the |
mjr | 87:8d35c74403af | 5800 | // full release motion, then return to real readings. |
mjr | 87:8d35c74403af | 5801 | if (uint32_t(r.t - f0.t) < 250000) |
mjr | 50:40015764bbe6 | 5802 | { |
mjr | 87:8d35c74403af | 5803 | // stay here a while longer |
mjr | 87:8d35c74403af | 5804 | z = 0; |
mjr | 50:40015764bbe6 | 5805 | } |
mjr | 50:40015764bbe6 | 5806 | else |
mjr | 50:40015764bbe6 | 5807 | { |
mjr | 87:8d35c74403af | 5808 | // it's been long enough - return to normal mode |
mjr | 87:8d35c74403af | 5809 | firingMode(0); |
mjr | 50:40015764bbe6 | 5810 | } |
mjr | 50:40015764bbe6 | 5811 | break; |
mjr | 50:40015764bbe6 | 5812 | } |
mjr | 50:40015764bbe6 | 5813 | |
mjr | 82:4f6209cb5c33 | 5814 | // Check for auto-zeroing, if enabled |
mjr | 82:4f6209cb5c33 | 5815 | if ((cfg.plunger.autoZero.flags & PlungerAutoZeroEnabled) != 0) |
mjr | 82:4f6209cb5c33 | 5816 | { |
mjr | 82:4f6209cb5c33 | 5817 | // If we moved since the last reading, reset and restart the |
mjr | 82:4f6209cb5c33 | 5818 | // auto-zero timer. Otherwise, if the timer has reached the |
mjr | 82:4f6209cb5c33 | 5819 | // auto-zero timeout, it means we've been motionless for that |
mjr | 82:4f6209cb5c33 | 5820 | // long, so auto-zero now. |
mjr | 82:4f6209cb5c33 | 5821 | if (r.pos != prv.pos) |
mjr | 82:4f6209cb5c33 | 5822 | { |
mjr | 82:4f6209cb5c33 | 5823 | // movement detected - reset the timer |
mjr | 82:4f6209cb5c33 | 5824 | autoZeroTimer.reset(); |
mjr | 82:4f6209cb5c33 | 5825 | autoZeroTimer.start(); |
mjr | 82:4f6209cb5c33 | 5826 | } |
mjr | 82:4f6209cb5c33 | 5827 | else if (autoZeroTimer.read_us() > cfg.plunger.autoZero.t * 1000000UL) |
mjr | 82:4f6209cb5c33 | 5828 | { |
mjr | 82:4f6209cb5c33 | 5829 | // auto-zero now |
mjr | 82:4f6209cb5c33 | 5830 | plungerSensor->autoZero(); |
mjr | 82:4f6209cb5c33 | 5831 | |
mjr | 82:4f6209cb5c33 | 5832 | // stop the timer so that we don't keep repeating this |
mjr | 82:4f6209cb5c33 | 5833 | // if the plunger stays still for a long time |
mjr | 82:4f6209cb5c33 | 5834 | autoZeroTimer.stop(); |
mjr | 82:4f6209cb5c33 | 5835 | autoZeroTimer.reset(); |
mjr | 82:4f6209cb5c33 | 5836 | } |
mjr | 82:4f6209cb5c33 | 5837 | } |
mjr | 82:4f6209cb5c33 | 5838 | |
mjr | 87:8d35c74403af | 5839 | // this new reading becomes the previous reading for next time |
mjr | 87:8d35c74403af | 5840 | prv = r; |
mjr | 48:058ace2aed1d | 5841 | } |
mjr | 48:058ace2aed1d | 5842 | } |
mjr | 48:058ace2aed1d | 5843 | |
mjr | 48:058ace2aed1d | 5844 | // Get the current value to report through the joystick interface |
mjr | 58:523fdcffbe6d | 5845 | int16_t getPosition() |
mjr | 58:523fdcffbe6d | 5846 | { |
mjr | 86:e30a1f60f783 | 5847 | // return the last reading |
mjr | 86:e30a1f60f783 | 5848 | return z; |
mjr | 55:4db125cd11a0 | 5849 | } |
mjr | 58:523fdcffbe6d | 5850 | |
mjr | 48:058ace2aed1d | 5851 | // Set calibration mode on or off |
mjr | 52:8298b2a73eb2 | 5852 | void setCalMode(bool f) |
mjr | 48:058ace2aed1d | 5853 | { |
mjr | 52:8298b2a73eb2 | 5854 | // check to see if we're entering calibration mode |
mjr | 52:8298b2a73eb2 | 5855 | if (f && !plungerCalMode) |
mjr | 52:8298b2a73eb2 | 5856 | { |
mjr | 52:8298b2a73eb2 | 5857 | // reset the calibration in the configuration |
mjr | 48:058ace2aed1d | 5858 | cfg.plunger.cal.begin(); |
mjr | 52:8298b2a73eb2 | 5859 | |
mjr | 52:8298b2a73eb2 | 5860 | // start in state 0 (waiting to settle) |
mjr | 52:8298b2a73eb2 | 5861 | calState = 0; |
mjr | 52:8298b2a73eb2 | 5862 | calZeroPosSum = 0; |
mjr | 52:8298b2a73eb2 | 5863 | calZeroPosN = 0; |
mjr | 52:8298b2a73eb2 | 5864 | calRlsTimeSum = 0; |
mjr | 52:8298b2a73eb2 | 5865 | calRlsTimeN = 0; |
mjr | 52:8298b2a73eb2 | 5866 | |
mjr | 82:4f6209cb5c33 | 5867 | // tell the plunger we're starting calibration |
mjr | 100:1ff35c07217c | 5868 | plungerSensor->beginCalibration(cfg); |
mjr | 82:4f6209cb5c33 | 5869 | |
mjr | 52:8298b2a73eb2 | 5870 | // set the initial zero point to the current position |
mjr | 52:8298b2a73eb2 | 5871 | PlungerReading r; |
mjr | 52:8298b2a73eb2 | 5872 | if (plungerSensor->read(r)) |
mjr | 52:8298b2a73eb2 | 5873 | { |
mjr | 52:8298b2a73eb2 | 5874 | // got a reading - use it as the initial zero point |
mjr | 52:8298b2a73eb2 | 5875 | cfg.plunger.cal.zero = r.pos; |
mjr | 76:7f5912b6340e | 5876 | onUpdateCal(); |
mjr | 52:8298b2a73eb2 | 5877 | |
mjr | 52:8298b2a73eb2 | 5878 | // use it as the starting point for the settling watch |
mjr | 53:9b2611964afc | 5879 | calZeroStart = r; |
mjr | 52:8298b2a73eb2 | 5880 | } |
mjr | 52:8298b2a73eb2 | 5881 | else |
mjr | 52:8298b2a73eb2 | 5882 | { |
mjr | 52:8298b2a73eb2 | 5883 | // no reading available - use the default 1/6 position |
mjr | 52:8298b2a73eb2 | 5884 | cfg.plunger.cal.zero = 0xffff/6; |
mjr | 76:7f5912b6340e | 5885 | onUpdateCal(); |
mjr | 52:8298b2a73eb2 | 5886 | |
mjr | 52:8298b2a73eb2 | 5887 | // we don't have a starting point for the setting watch |
mjr | 53:9b2611964afc | 5888 | calZeroStart.pos = -65535; |
mjr | 53:9b2611964afc | 5889 | calZeroStart.t = 0; |
mjr | 53:9b2611964afc | 5890 | } |
mjr | 53:9b2611964afc | 5891 | } |
mjr | 53:9b2611964afc | 5892 | else if (!f && plungerCalMode) |
mjr | 53:9b2611964afc | 5893 | { |
mjr | 53:9b2611964afc | 5894 | // Leaving calibration mode. Make sure the max is past the |
mjr | 53:9b2611964afc | 5895 | // zero point - if it's not, we'd have a zero or negative |
mjr | 53:9b2611964afc | 5896 | // denominator for the scaling calculation, which would be |
mjr | 53:9b2611964afc | 5897 | // physically meaningless. |
mjr | 53:9b2611964afc | 5898 | if (cfg.plunger.cal.max <= cfg.plunger.cal.zero) |
mjr | 53:9b2611964afc | 5899 | { |
mjr | 53:9b2611964afc | 5900 | // bad settings - reset to defaults |
mjr | 53:9b2611964afc | 5901 | cfg.plunger.cal.max = 0xffff; |
mjr | 53:9b2611964afc | 5902 | cfg.plunger.cal.zero = 0xffff/6; |
mjr | 52:8298b2a73eb2 | 5903 | } |
mjr | 100:1ff35c07217c | 5904 | |
mjr | 100:1ff35c07217c | 5905 | // finalize the configuration in the plunger object |
mjr | 100:1ff35c07217c | 5906 | plungerSensor->endCalibration(cfg); |
mjr | 100:1ff35c07217c | 5907 | |
mjr | 100:1ff35c07217c | 5908 | // update our internal cached information for the new calibration |
mjr | 100:1ff35c07217c | 5909 | onUpdateCal(); |
mjr | 52:8298b2a73eb2 | 5910 | } |
mjr | 52:8298b2a73eb2 | 5911 | |
mjr | 48:058ace2aed1d | 5912 | // remember the new mode |
mjr | 52:8298b2a73eb2 | 5913 | plungerCalMode = f; |
mjr | 48:058ace2aed1d | 5914 | } |
mjr | 48:058ace2aed1d | 5915 | |
mjr | 76:7f5912b6340e | 5916 | // Cached inverse of the calibration range. This is for calculating |
mjr | 76:7f5912b6340e | 5917 | // the calibrated plunger position given a raw sensor reading. The |
mjr | 76:7f5912b6340e | 5918 | // cached inverse is calculated as |
mjr | 76:7f5912b6340e | 5919 | // |
mjr | 76:7f5912b6340e | 5920 | // 64K * JOYMAX / (cfg.plunger.cal.max - cfg.plunger.cal.zero) |
mjr | 76:7f5912b6340e | 5921 | // |
mjr | 76:7f5912b6340e | 5922 | // To convert a raw sensor reading to a calibrated position, calculate |
mjr | 76:7f5912b6340e | 5923 | // |
mjr | 76:7f5912b6340e | 5924 | // ((reading - cfg.plunger.cal.zero)*invCalRange) >> 16 |
mjr | 76:7f5912b6340e | 5925 | // |
mjr | 76:7f5912b6340e | 5926 | // That yields the calibration result without performing a division. |
mjr | 76:7f5912b6340e | 5927 | int invCalRange; |
mjr | 76:7f5912b6340e | 5928 | |
mjr | 76:7f5912b6340e | 5929 | // apply the calibration range to a reading |
mjr | 76:7f5912b6340e | 5930 | inline int applyCal(int reading) |
mjr | 76:7f5912b6340e | 5931 | { |
mjr | 76:7f5912b6340e | 5932 | return ((reading - cfg.plunger.cal.zero)*invCalRange) >> 16; |
mjr | 76:7f5912b6340e | 5933 | } |
mjr | 76:7f5912b6340e | 5934 | |
mjr | 76:7f5912b6340e | 5935 | void onUpdateCal() |
mjr | 76:7f5912b6340e | 5936 | { |
mjr | 76:7f5912b6340e | 5937 | invCalRange = (JOYMAX << 16)/(cfg.plunger.cal.max - cfg.plunger.cal.zero); |
mjr | 76:7f5912b6340e | 5938 | } |
mjr | 76:7f5912b6340e | 5939 | |
mjr | 48:058ace2aed1d | 5940 | // is a firing event in progress? |
mjr | 53:9b2611964afc | 5941 | bool isFiring() { return firing == 3; } |
mjr | 76:7f5912b6340e | 5942 | |
mjr | 48:058ace2aed1d | 5943 | private: |
mjr | 87:8d35c74403af | 5944 | // current reported joystick reading |
mjr | 87:8d35c74403af | 5945 | int z; |
mjr | 87:8d35c74403af | 5946 | |
mjr | 87:8d35c74403af | 5947 | // previous reading |
mjr | 87:8d35c74403af | 5948 | PlungerReading prv; |
mjr | 87:8d35c74403af | 5949 | |
mjr | 52:8298b2a73eb2 | 5950 | // Calibration state. During calibration mode, we watch for release |
mjr | 52:8298b2a73eb2 | 5951 | // events, to measure the time it takes to complete the release |
mjr | 52:8298b2a73eb2 | 5952 | // motion; and we watch for the plunger to come to reset after a |
mjr | 52:8298b2a73eb2 | 5953 | // release, to gather statistics on the rest position. |
mjr | 52:8298b2a73eb2 | 5954 | // 0 = waiting to settle |
mjr | 52:8298b2a73eb2 | 5955 | // 1 = at rest |
mjr | 52:8298b2a73eb2 | 5956 | // 2 = retracting |
mjr | 52:8298b2a73eb2 | 5957 | // 3 = possibly releasing |
mjr | 52:8298b2a73eb2 | 5958 | uint8_t calState; |
mjr | 52:8298b2a73eb2 | 5959 | |
mjr | 52:8298b2a73eb2 | 5960 | // Calibration zero point statistics. |
mjr | 52:8298b2a73eb2 | 5961 | // During calibration mode, we collect data on the rest position (the |
mjr | 52:8298b2a73eb2 | 5962 | // zero point) by watching for the plunger to come to rest after each |
mjr | 52:8298b2a73eb2 | 5963 | // release. We average these rest positions to get the calibrated |
mjr | 52:8298b2a73eb2 | 5964 | // zero point. We use the average because the real physical plunger |
mjr | 52:8298b2a73eb2 | 5965 | // itself doesn't come to rest at exactly the same spot every time, |
mjr | 52:8298b2a73eb2 | 5966 | // largely due to friction in the mechanism. To calculate the average, |
mjr | 52:8298b2a73eb2 | 5967 | // we keep a sum of the readings and a count of samples. |
mjr | 53:9b2611964afc | 5968 | PlungerReading calZeroStart; |
mjr | 52:8298b2a73eb2 | 5969 | long calZeroPosSum; |
mjr | 52:8298b2a73eb2 | 5970 | int calZeroPosN; |
mjr | 52:8298b2a73eb2 | 5971 | |
mjr | 52:8298b2a73eb2 | 5972 | // Calibration release time statistics. |
mjr | 52:8298b2a73eb2 | 5973 | // During calibration, we collect an average for the release time. |
mjr | 52:8298b2a73eb2 | 5974 | long calRlsTimeSum; |
mjr | 52:8298b2a73eb2 | 5975 | int calRlsTimeN; |
mjr | 52:8298b2a73eb2 | 5976 | |
mjr | 85:3c28aee81cde | 5977 | // Auto-zeroing timer |
mjr | 85:3c28aee81cde | 5978 | Timer autoZeroTimer; |
mjr | 85:3c28aee81cde | 5979 | |
mjr | 48:058ace2aed1d | 5980 | // set a firing mode |
mjr | 48:058ace2aed1d | 5981 | inline void firingMode(int m) |
mjr | 48:058ace2aed1d | 5982 | { |
mjr | 48:058ace2aed1d | 5983 | firing = m; |
mjr | 48:058ace2aed1d | 5984 | } |
mjr | 48:058ace2aed1d | 5985 | |
mjr | 48:058ace2aed1d | 5986 | // Firing event state. |
mjr | 48:058ace2aed1d | 5987 | // |
mjr | 87:8d35c74403af | 5988 | // 0 - Default state: not in firing event. We report the true |
mjr | 87:8d35c74403af | 5989 | // instantaneous plunger position to the joystick interface. |
mjr | 48:058ace2aed1d | 5990 | // |
mjr | 87:8d35c74403af | 5991 | // 1 - Moving forward at release speed |
mjr | 48:058ace2aed1d | 5992 | // |
mjr | 87:8d35c74403af | 5993 | // 2 - Firing - reporting the bounce position |
mjr | 87:8d35c74403af | 5994 | // |
mjr | 87:8d35c74403af | 5995 | // 3 - Firing - reporting the park position |
mjr | 48:058ace2aed1d | 5996 | // |
mjr | 48:058ace2aed1d | 5997 | int firing; |
mjr | 48:058ace2aed1d | 5998 | |
mjr | 87:8d35c74403af | 5999 | // Starting position for current firing mode phase |
mjr | 87:8d35c74403af | 6000 | PlungerReading f0; |
mjr | 48:058ace2aed1d | 6001 | }; |
mjr | 48:058ace2aed1d | 6002 | |
mjr | 48:058ace2aed1d | 6003 | // plunger reader singleton |
mjr | 48:058ace2aed1d | 6004 | PlungerReader plungerReader; |
mjr | 48:058ace2aed1d | 6005 | |
mjr | 48:058ace2aed1d | 6006 | // --------------------------------------------------------------------------- |
mjr | 48:058ace2aed1d | 6007 | // |
mjr | 48:058ace2aed1d | 6008 | // Handle the ZB Launch Ball feature. |
mjr | 48:058ace2aed1d | 6009 | // |
mjr | 48:058ace2aed1d | 6010 | // The ZB Launch Ball feature, if enabled, lets the mechanical plunger |
mjr | 48:058ace2aed1d | 6011 | // serve as a substitute for a physical Launch Ball button. When a table |
mjr | 48:058ace2aed1d | 6012 | // is loaded in VP, and the table has the ZB Launch Ball LedWiz port |
mjr | 48:058ace2aed1d | 6013 | // turned on, we'll disable mechanical plunger reports through the |
mjr | 48:058ace2aed1d | 6014 | // joystick interface and instead use the plunger only to simulate the |
mjr | 48:058ace2aed1d | 6015 | // Launch Ball button. When the mode is active, pulling back and |
mjr | 48:058ace2aed1d | 6016 | // releasing the plunger causes a brief simulated press of the Launch |
mjr | 48:058ace2aed1d | 6017 | // button, and pushing the plunger forward of the rest position presses |
mjr | 48:058ace2aed1d | 6018 | // the Launch button as long as the plunger is pressed forward. |
mjr | 48:058ace2aed1d | 6019 | // |
mjr | 48:058ace2aed1d | 6020 | // This feature has two configuration components: |
mjr | 48:058ace2aed1d | 6021 | // |
mjr | 48:058ace2aed1d | 6022 | // - An LedWiz port number. This port is a "virtual" port that doesn't |
mjr | 48:058ace2aed1d | 6023 | // have to be attached to any actual output. DOF uses it to signal |
mjr | 48:058ace2aed1d | 6024 | // that the current table uses a Launch button instead of a plunger. |
mjr | 48:058ace2aed1d | 6025 | // DOF simply turns the port on when such a table is loaded and turns |
mjr | 48:058ace2aed1d | 6026 | // it off at all other times. We use it to enable and disable the |
mjr | 48:058ace2aed1d | 6027 | // plunger/launch button connection. |
mjr | 48:058ace2aed1d | 6028 | // |
mjr | 48:058ace2aed1d | 6029 | // - A joystick button ID. We simulate pressing this button when the |
mjr | 48:058ace2aed1d | 6030 | // launch feature is activated via the LedWiz port and the plunger is |
mjr | 48:058ace2aed1d | 6031 | // either pulled back and releasd, or pushed forward past the rest |
mjr | 48:058ace2aed1d | 6032 | // position. |
mjr | 48:058ace2aed1d | 6033 | // |
mjr | 48:058ace2aed1d | 6034 | class ZBLaunchBall |
mjr | 48:058ace2aed1d | 6035 | { |
mjr | 48:058ace2aed1d | 6036 | public: |
mjr | 48:058ace2aed1d | 6037 | ZBLaunchBall() |
mjr | 48:058ace2aed1d | 6038 | { |
mjr | 48:058ace2aed1d | 6039 | // start in the default state |
mjr | 48:058ace2aed1d | 6040 | lbState = 0; |
mjr | 53:9b2611964afc | 6041 | btnState = false; |
mjr | 48:058ace2aed1d | 6042 | } |
mjr | 48:058ace2aed1d | 6043 | |
mjr | 48:058ace2aed1d | 6044 | // Update state. This checks the current plunger position and |
mjr | 48:058ace2aed1d | 6045 | // the timers to see if the plunger is in a position that simulates |
mjr | 48:058ace2aed1d | 6046 | // a Launch Ball button press via the ZB Launch Ball feature. |
mjr | 48:058ace2aed1d | 6047 | // Updates the simulated button vector according to the current |
mjr | 48:058ace2aed1d | 6048 | // launch ball state. The main loop calls this before each |
mjr | 48:058ace2aed1d | 6049 | // joystick update to figure the new simulated button state. |
mjr | 53:9b2611964afc | 6050 | void update() |
mjr | 48:058ace2aed1d | 6051 | { |
mjr | 53:9b2611964afc | 6052 | // If the ZB Launch Ball led wiz output is ON, check for a |
mjr | 53:9b2611964afc | 6053 | // plunger firing event |
mjr | 53:9b2611964afc | 6054 | if (zbLaunchOn) |
mjr | 48:058ace2aed1d | 6055 | { |
mjr | 53:9b2611964afc | 6056 | // note the new position |
mjr | 48:058ace2aed1d | 6057 | int znew = plungerReader.getPosition(); |
mjr | 53:9b2611964afc | 6058 | |
mjr | 53:9b2611964afc | 6059 | // figure the push threshold from the configuration data |
mjr | 51:57eb311faafa | 6060 | const int pushThreshold = int(-JOYMAX/3.0 * cfg.plunger.zbLaunchBall.pushDistance/1000.0); |
mjr | 53:9b2611964afc | 6061 | |
mjr | 53:9b2611964afc | 6062 | // check the state |
mjr | 48:058ace2aed1d | 6063 | switch (lbState) |
mjr | 48:058ace2aed1d | 6064 | { |
mjr | 48:058ace2aed1d | 6065 | case 0: |
mjr | 53:9b2611964afc | 6066 | // Default state. If a launch event has been detected on |
mjr | 53:9b2611964afc | 6067 | // the plunger, activate a timed pulse and switch to state 1. |
mjr | 53:9b2611964afc | 6068 | // If the plunger is pushed forward of the threshold, push |
mjr | 53:9b2611964afc | 6069 | // the button. |
mjr | 53:9b2611964afc | 6070 | if (plungerReader.isFiring()) |
mjr | 53:9b2611964afc | 6071 | { |
mjr | 53:9b2611964afc | 6072 | // firing event - start a timed Launch button pulse |
mjr | 53:9b2611964afc | 6073 | lbTimer.reset(); |
mjr | 53:9b2611964afc | 6074 | lbTimer.start(); |
mjr | 53:9b2611964afc | 6075 | setButton(true); |
mjr | 53:9b2611964afc | 6076 | |
mjr | 53:9b2611964afc | 6077 | // switch to state 1 |
mjr | 53:9b2611964afc | 6078 | lbState = 1; |
mjr | 53:9b2611964afc | 6079 | } |
mjr | 48:058ace2aed1d | 6080 | else if (znew <= pushThreshold) |
mjr | 53:9b2611964afc | 6081 | { |
mjr | 53:9b2611964afc | 6082 | // pushed forward without a firing event - hold the |
mjr | 53:9b2611964afc | 6083 | // button as long as we're pushed forward |
mjr | 53:9b2611964afc | 6084 | setButton(true); |
mjr | 53:9b2611964afc | 6085 | } |
mjr | 53:9b2611964afc | 6086 | else |
mjr | 53:9b2611964afc | 6087 | { |
mjr | 53:9b2611964afc | 6088 | // not pushed forward - turn off the Launch button |
mjr | 53:9b2611964afc | 6089 | setButton(false); |
mjr | 53:9b2611964afc | 6090 | } |
mjr | 48:058ace2aed1d | 6091 | break; |
mjr | 48:058ace2aed1d | 6092 | |
mjr | 48:058ace2aed1d | 6093 | case 1: |
mjr | 53:9b2611964afc | 6094 | // State 1: Timed Launch button pulse in progress after a |
mjr | 53:9b2611964afc | 6095 | // firing event. Wait for the timer to expire. |
mjr | 53:9b2611964afc | 6096 | if (lbTimer.read_us() > 200000UL) |
mjr | 53:9b2611964afc | 6097 | { |
mjr | 53:9b2611964afc | 6098 | // timer expired - turn off the button |
mjr | 53:9b2611964afc | 6099 | setButton(false); |
mjr | 53:9b2611964afc | 6100 | |
mjr | 53:9b2611964afc | 6101 | // switch to state 2 |
mjr | 53:9b2611964afc | 6102 | lbState = 2; |
mjr | 53:9b2611964afc | 6103 | } |
mjr | 48:058ace2aed1d | 6104 | break; |
mjr | 48:058ace2aed1d | 6105 | |
mjr | 48:058ace2aed1d | 6106 | case 2: |
mjr | 53:9b2611964afc | 6107 | // State 2: Timed Launch button pulse done. Wait for the |
mjr | 53:9b2611964afc | 6108 | // plunger launch event to end. |
mjr | 53:9b2611964afc | 6109 | if (!plungerReader.isFiring()) |
mjr | 53:9b2611964afc | 6110 | { |
mjr | 53:9b2611964afc | 6111 | // firing event done - return to default state |
mjr | 53:9b2611964afc | 6112 | lbState = 0; |
mjr | 53:9b2611964afc | 6113 | } |
mjr | 48:058ace2aed1d | 6114 | break; |
mjr | 48:058ace2aed1d | 6115 | } |
mjr | 53:9b2611964afc | 6116 | } |
mjr | 53:9b2611964afc | 6117 | else |
mjr | 53:9b2611964afc | 6118 | { |
mjr | 53:9b2611964afc | 6119 | // ZB Launch Ball disabled - turn off the button if it was on |
mjr | 53:9b2611964afc | 6120 | setButton(false); |
mjr | 48:058ace2aed1d | 6121 | |
mjr | 53:9b2611964afc | 6122 | // return to the default state |
mjr | 53:9b2611964afc | 6123 | lbState = 0; |
mjr | 48:058ace2aed1d | 6124 | } |
mjr | 48:058ace2aed1d | 6125 | } |
mjr | 53:9b2611964afc | 6126 | |
mjr | 53:9b2611964afc | 6127 | // Set the button state |
mjr | 53:9b2611964afc | 6128 | void setButton(bool on) |
mjr | 53:9b2611964afc | 6129 | { |
mjr | 53:9b2611964afc | 6130 | if (btnState != on) |
mjr | 53:9b2611964afc | 6131 | { |
mjr | 53:9b2611964afc | 6132 | // remember the new state |
mjr | 53:9b2611964afc | 6133 | btnState = on; |
mjr | 53:9b2611964afc | 6134 | |
mjr | 53:9b2611964afc | 6135 | // update the virtual button state |
mjr | 65:739875521aae | 6136 | buttonState[zblButtonIndex].virtPress(on); |
mjr | 53:9b2611964afc | 6137 | } |
mjr | 53:9b2611964afc | 6138 | } |
mjr | 53:9b2611964afc | 6139 | |
mjr | 48:058ace2aed1d | 6140 | private: |
mjr | 48:058ace2aed1d | 6141 | // Simulated Launch Ball button state. If a "ZB Launch Ball" port is |
mjr | 48:058ace2aed1d | 6142 | // defined for our LedWiz port mapping, any time that port is turned ON, |
mjr | 48:058ace2aed1d | 6143 | // we'll simulate pushing the Launch Ball button if the player pulls |
mjr | 48:058ace2aed1d | 6144 | // back and releases the plunger, or simply pushes on the plunger from |
mjr | 48:058ace2aed1d | 6145 | // the rest position. This allows the plunger to be used in lieu of a |
mjr | 48:058ace2aed1d | 6146 | // physical Launch Ball button for tables that don't have plungers. |
mjr | 48:058ace2aed1d | 6147 | // |
mjr | 48:058ace2aed1d | 6148 | // States: |
mjr | 48:058ace2aed1d | 6149 | // 0 = default |
mjr | 53:9b2611964afc | 6150 | // 1 = firing (firing event has activated a Launch button pulse) |
mjr | 53:9b2611964afc | 6151 | // 2 = firing done (Launch button pulse ended, waiting for plunger |
mjr | 53:9b2611964afc | 6152 | // firing event to end) |
mjr | 53:9b2611964afc | 6153 | uint8_t lbState; |
mjr | 48:058ace2aed1d | 6154 | |
mjr | 53:9b2611964afc | 6155 | // button state |
mjr | 53:9b2611964afc | 6156 | bool btnState; |
mjr | 48:058ace2aed1d | 6157 | |
mjr | 48:058ace2aed1d | 6158 | // Time since last lbState transition. Some of the states are time- |
mjr | 48:058ace2aed1d | 6159 | // sensitive. In the "uncocked" state, we'll return to state 0 if |
mjr | 48:058ace2aed1d | 6160 | // we remain in this state for more than a few milliseconds, since |
mjr | 48:058ace2aed1d | 6161 | // it indicates that the plunger is being slowly returned to rest |
mjr | 48:058ace2aed1d | 6162 | // rather than released. In the "launching" state, we need to release |
mjr | 48:058ace2aed1d | 6163 | // the Launch Ball button after a moment, and we need to wait for |
mjr | 48:058ace2aed1d | 6164 | // the plunger to come to rest before returning to state 0. |
mjr | 48:058ace2aed1d | 6165 | Timer lbTimer; |
mjr | 48:058ace2aed1d | 6166 | }; |
mjr | 48:058ace2aed1d | 6167 | |
mjr | 35:e959ffba78fd | 6168 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 6169 | // |
mjr | 35:e959ffba78fd | 6170 | // Reboot - resets the microcontroller |
mjr | 35:e959ffba78fd | 6171 | // |
mjr | 54:fd77a6b2f76c | 6172 | void reboot(USBJoystick &js, bool disconnect = true, long pause_us = 2000000L) |
mjr | 35:e959ffba78fd | 6173 | { |
mjr | 35:e959ffba78fd | 6174 | // disconnect from USB |
mjr | 54:fd77a6b2f76c | 6175 | if (disconnect) |
mjr | 54:fd77a6b2f76c | 6176 | js.disconnect(); |
mjr | 35:e959ffba78fd | 6177 | |
mjr | 35:e959ffba78fd | 6178 | // wait a few seconds to make sure the host notices the disconnect |
mjr | 54:fd77a6b2f76c | 6179 | wait_us(pause_us); |
mjr | 35:e959ffba78fd | 6180 | |
mjr | 35:e959ffba78fd | 6181 | // reset the device |
mjr | 35:e959ffba78fd | 6182 | NVIC_SystemReset(); |
mjr | 35:e959ffba78fd | 6183 | while (true) { } |
mjr | 35:e959ffba78fd | 6184 | } |
mjr | 35:e959ffba78fd | 6185 | |
mjr | 35:e959ffba78fd | 6186 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 6187 | // |
mjr | 35:e959ffba78fd | 6188 | // Translate joystick readings from raw values to reported values, based |
mjr | 35:e959ffba78fd | 6189 | // on the orientation of the controller card in the cabinet. |
mjr | 35:e959ffba78fd | 6190 | // |
mjr | 35:e959ffba78fd | 6191 | void accelRotate(int &x, int &y) |
mjr | 35:e959ffba78fd | 6192 | { |
mjr | 35:e959ffba78fd | 6193 | int tmp; |
mjr | 78:1e00b3fa11af | 6194 | switch (cfg.accel.orientation) |
mjr | 35:e959ffba78fd | 6195 | { |
mjr | 35:e959ffba78fd | 6196 | case OrientationFront: |
mjr | 35:e959ffba78fd | 6197 | tmp = x; |
mjr | 35:e959ffba78fd | 6198 | x = y; |
mjr | 35:e959ffba78fd | 6199 | y = tmp; |
mjr | 35:e959ffba78fd | 6200 | break; |
mjr | 35:e959ffba78fd | 6201 | |
mjr | 35:e959ffba78fd | 6202 | case OrientationLeft: |
mjr | 35:e959ffba78fd | 6203 | x = -x; |
mjr | 35:e959ffba78fd | 6204 | break; |
mjr | 35:e959ffba78fd | 6205 | |
mjr | 35:e959ffba78fd | 6206 | case OrientationRight: |
mjr | 35:e959ffba78fd | 6207 | y = -y; |
mjr | 35:e959ffba78fd | 6208 | break; |
mjr | 35:e959ffba78fd | 6209 | |
mjr | 35:e959ffba78fd | 6210 | case OrientationRear: |
mjr | 35:e959ffba78fd | 6211 | tmp = -x; |
mjr | 35:e959ffba78fd | 6212 | x = -y; |
mjr | 35:e959ffba78fd | 6213 | y = tmp; |
mjr | 35:e959ffba78fd | 6214 | break; |
mjr | 35:e959ffba78fd | 6215 | } |
mjr | 35:e959ffba78fd | 6216 | } |
mjr | 35:e959ffba78fd | 6217 | |
mjr | 35:e959ffba78fd | 6218 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 6219 | // |
mjr | 35:e959ffba78fd | 6220 | // Calibration button state: |
mjr | 35:e959ffba78fd | 6221 | // 0 = not pushed |
mjr | 35:e959ffba78fd | 6222 | // 1 = pushed, not yet debounced |
mjr | 35:e959ffba78fd | 6223 | // 2 = pushed, debounced, waiting for hold time |
mjr | 35:e959ffba78fd | 6224 | // 3 = pushed, hold time completed - in calibration mode |
mjr | 35:e959ffba78fd | 6225 | int calBtnState = 0; |
mjr | 35:e959ffba78fd | 6226 | |
mjr | 35:e959ffba78fd | 6227 | // calibration button debounce timer |
mjr | 35:e959ffba78fd | 6228 | Timer calBtnTimer; |
mjr | 35:e959ffba78fd | 6229 | |
mjr | 35:e959ffba78fd | 6230 | // calibration button light state |
mjr | 35:e959ffba78fd | 6231 | int calBtnLit = false; |
mjr | 35:e959ffba78fd | 6232 | |
mjr | 35:e959ffba78fd | 6233 | |
mjr | 35:e959ffba78fd | 6234 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 6235 | // |
mjr | 40:cc0d9814522b | 6236 | // Configuration variable get/set message handling |
mjr | 35:e959ffba78fd | 6237 | // |
mjr | 40:cc0d9814522b | 6238 | |
mjr | 40:cc0d9814522b | 6239 | // Handle SET messages - write configuration variables from USB message data |
mjr | 40:cc0d9814522b | 6240 | #define if_msg_valid(test) if (test) |
mjr | 53:9b2611964afc | 6241 | #define v_byte(var, ofs) cfg.var = data[ofs] |
mjr | 91:ae9be42652bf | 6242 | #define v_byte_wo(var, ofs) cfg.var = data[ofs] |
mjr | 53:9b2611964afc | 6243 | #define v_ui16(var, ofs) cfg.var = wireUI16(data+(ofs)) |
mjr | 77:0b96f6867312 | 6244 | #define v_ui32(var, ofs) cfg.var = wireUI32(data+(ofs)) |
mjr | 53:9b2611964afc | 6245 | #define v_pin(var, ofs) cfg.var = wirePinName(data[ofs]) |
mjr | 53:9b2611964afc | 6246 | #define v_byte_ro(val, ofs) // ignore read-only variables on SET |
mjr | 74:822a92bc11d2 | 6247 | #define v_ui32_ro(val, ofs) // ignore read-only variables on SET |
mjr | 74:822a92bc11d2 | 6248 | #define VAR_MODE_SET 1 // we're in SET mode |
mjr | 76:7f5912b6340e | 6249 | #define v_func configVarSet(const uint8_t *data) |
mjr | 40:cc0d9814522b | 6250 | #include "cfgVarMsgMap.h" |
mjr | 35:e959ffba78fd | 6251 | |
mjr | 40:cc0d9814522b | 6252 | // redefine everything for the SET messages |
mjr | 40:cc0d9814522b | 6253 | #undef if_msg_valid |
mjr | 40:cc0d9814522b | 6254 | #undef v_byte |
mjr | 40:cc0d9814522b | 6255 | #undef v_ui16 |
mjr | 77:0b96f6867312 | 6256 | #undef v_ui32 |
mjr | 40:cc0d9814522b | 6257 | #undef v_pin |
mjr | 53:9b2611964afc | 6258 | #undef v_byte_ro |
mjr | 91:ae9be42652bf | 6259 | #undef v_byte_wo |
mjr | 74:822a92bc11d2 | 6260 | #undef v_ui32_ro |
mjr | 74:822a92bc11d2 | 6261 | #undef VAR_MODE_SET |
mjr | 40:cc0d9814522b | 6262 | #undef v_func |
mjr | 38:091e511ce8a0 | 6263 | |
mjr | 91:ae9be42652bf | 6264 | // Handle GET messages - read variable values and return in USB message data |
mjr | 40:cc0d9814522b | 6265 | #define if_msg_valid(test) |
mjr | 53:9b2611964afc | 6266 | #define v_byte(var, ofs) data[ofs] = cfg.var |
mjr | 53:9b2611964afc | 6267 | #define v_ui16(var, ofs) ui16Wire(data+(ofs), cfg.var) |
mjr | 77:0b96f6867312 | 6268 | #define v_ui32(var, ofs) ui32Wire(data+(ofs), cfg.var) |
mjr | 53:9b2611964afc | 6269 | #define v_pin(var, ofs) pinNameWire(data+(ofs), cfg.var) |
mjr | 73:4e8ce0b18915 | 6270 | #define v_byte_ro(val, ofs) data[ofs] = (val) |
mjr | 74:822a92bc11d2 | 6271 | #define v_ui32_ro(val, ofs) ui32Wire(data+(ofs), val); |
mjr | 74:822a92bc11d2 | 6272 | #define VAR_MODE_SET 0 // we're in GET mode |
mjr | 91:ae9be42652bf | 6273 | #define v_byte_wo(var, ofs) // ignore write-only variables in GET mode |
mjr | 76:7f5912b6340e | 6274 | #define v_func configVarGet(uint8_t *data) |
mjr | 40:cc0d9814522b | 6275 | #include "cfgVarMsgMap.h" |
mjr | 40:cc0d9814522b | 6276 | |
mjr | 35:e959ffba78fd | 6277 | |
mjr | 35:e959ffba78fd | 6278 | // --------------------------------------------------------------------------- |
mjr | 35:e959ffba78fd | 6279 | // |
mjr | 101:755f44622abc | 6280 | // Timer for timestamping input requests |
mjr | 101:755f44622abc | 6281 | // |
mjr | 101:755f44622abc | 6282 | Timer requestTimestamper; |
mjr | 101:755f44622abc | 6283 | |
mjr | 101:755f44622abc | 6284 | // --------------------------------------------------------------------------- |
mjr | 101:755f44622abc | 6285 | // |
mjr | 35:e959ffba78fd | 6286 | // Handle an input report from the USB host. Input reports use our extended |
mjr | 35:e959ffba78fd | 6287 | // LedWiz protocol. |
mjr | 33:d832bcab089e | 6288 | // |
mjr | 78:1e00b3fa11af | 6289 | void handleInputMsg(LedWizMsg &lwm, USBJoystick &js, Accel &accel) |
mjr | 35:e959ffba78fd | 6290 | { |
mjr | 38:091e511ce8a0 | 6291 | // LedWiz commands come in two varieties: SBA and PBA. An |
mjr | 38:091e511ce8a0 | 6292 | // SBA is marked by the first byte having value 64 (0x40). In |
mjr | 38:091e511ce8a0 | 6293 | // the real LedWiz protocol, any other value in the first byte |
mjr | 38:091e511ce8a0 | 6294 | // means it's a PBA message. However, *valid* PBA messages |
mjr | 38:091e511ce8a0 | 6295 | // always have a first byte (and in fact all 8 bytes) in the |
mjr | 38:091e511ce8a0 | 6296 | // range 0-49 or 129-132. Anything else is invalid. We take |
mjr | 38:091e511ce8a0 | 6297 | // advantage of this to implement private protocol extensions. |
mjr | 38:091e511ce8a0 | 6298 | // So our full protocol is as follows: |
mjr | 38:091e511ce8a0 | 6299 | // |
mjr | 38:091e511ce8a0 | 6300 | // first byte = |
mjr | 74:822a92bc11d2 | 6301 | // 0-48 -> PBA |
mjr | 74:822a92bc11d2 | 6302 | // 64 -> SBA |
mjr | 38:091e511ce8a0 | 6303 | // 65 -> private control message; second byte specifies subtype |
mjr | 74:822a92bc11d2 | 6304 | // 129-132 -> PBA |
mjr | 38:091e511ce8a0 | 6305 | // 200-228 -> extended bank brightness set for outputs N to N+6, where |
mjr | 38:091e511ce8a0 | 6306 | // N is (first byte - 200)*7 |
mjr | 38:091e511ce8a0 | 6307 | // other -> reserved for future use |
mjr | 38:091e511ce8a0 | 6308 | // |
mjr | 39:b3815a1c3802 | 6309 | uint8_t *data = lwm.data; |
mjr | 74:822a92bc11d2 | 6310 | if (data[0] == 64) |
mjr | 35:e959ffba78fd | 6311 | { |
mjr | 74:822a92bc11d2 | 6312 | // 64 = SBA (original LedWiz command to set on/off switches for ports 1-32) |
mjr | 74:822a92bc11d2 | 6313 | //printf("SBA %02x %02x %02x %02x, speed %02x\r\n", |
mjr | 38:091e511ce8a0 | 6314 | // data[1], data[2], data[3], data[4], data[5]); |
mjr | 74:822a92bc11d2 | 6315 | sba_sbx(0, data); |
mjr | 74:822a92bc11d2 | 6316 | |
mjr | 74:822a92bc11d2 | 6317 | // SBA resets the PBA port group counter |
mjr | 38:091e511ce8a0 | 6318 | pbaIdx = 0; |
mjr | 38:091e511ce8a0 | 6319 | } |
mjr | 38:091e511ce8a0 | 6320 | else if (data[0] == 65) |
mjr | 38:091e511ce8a0 | 6321 | { |
mjr | 38:091e511ce8a0 | 6322 | // Private control message. This isn't an LedWiz message - it's |
mjr | 38:091e511ce8a0 | 6323 | // an extension for this device. 65 is an invalid PBA setting, |
mjr | 38:091e511ce8a0 | 6324 | // and isn't used for any other LedWiz message, so we appropriate |
mjr | 38:091e511ce8a0 | 6325 | // it for our own private use. The first byte specifies the |
mjr | 38:091e511ce8a0 | 6326 | // message type. |
mjr | 39:b3815a1c3802 | 6327 | switch (data[1]) |
mjr | 38:091e511ce8a0 | 6328 | { |
mjr | 39:b3815a1c3802 | 6329 | case 0: |
mjr | 39:b3815a1c3802 | 6330 | // No Op |
mjr | 39:b3815a1c3802 | 6331 | break; |
mjr | 39:b3815a1c3802 | 6332 | |
mjr | 39:b3815a1c3802 | 6333 | case 1: |
mjr | 38:091e511ce8a0 | 6334 | // 1 = Old Set Configuration: |
mjr | 38:091e511ce8a0 | 6335 | // data[2] = LedWiz unit number (0x00 to 0x0f) |
mjr | 38:091e511ce8a0 | 6336 | // data[3] = feature enable bit mask: |
mjr | 38:091e511ce8a0 | 6337 | // 0x01 = enable plunger sensor |
mjr | 39:b3815a1c3802 | 6338 | { |
mjr | 39:b3815a1c3802 | 6339 | |
mjr | 39:b3815a1c3802 | 6340 | // get the new LedWiz unit number - this is 0-15, whereas we |
mjr | 39:b3815a1c3802 | 6341 | // we save the *nominal* unit number 1-16 in the config |
mjr | 39:b3815a1c3802 | 6342 | uint8_t newUnitNo = (data[2] & 0x0f) + 1; |
mjr | 39:b3815a1c3802 | 6343 | |
mjr | 86:e30a1f60f783 | 6344 | // we'll need a reboot if the LedWiz unit number is changing |
mjr | 86:e30a1f60f783 | 6345 | bool reboot = (newUnitNo != cfg.psUnitNo); |
mjr | 39:b3815a1c3802 | 6346 | |
mjr | 39:b3815a1c3802 | 6347 | // set the configuration parameters from the message |
mjr | 39:b3815a1c3802 | 6348 | cfg.psUnitNo = newUnitNo; |
mjr | 39:b3815a1c3802 | 6349 | cfg.plunger.enabled = data[3] & 0x01; |
mjr | 39:b3815a1c3802 | 6350 | |
mjr | 77:0b96f6867312 | 6351 | // set the flag to do the save |
mjr | 86:e30a1f60f783 | 6352 | saveConfigToFlash(0, reboot); |
mjr | 39:b3815a1c3802 | 6353 | } |
mjr | 39:b3815a1c3802 | 6354 | break; |
mjr | 38:091e511ce8a0 | 6355 | |
mjr | 39:b3815a1c3802 | 6356 | case 2: |
mjr | 38:091e511ce8a0 | 6357 | // 2 = Calibrate plunger |
mjr | 38:091e511ce8a0 | 6358 | // (No parameters) |
mjr | 38:091e511ce8a0 | 6359 | |
mjr | 38:091e511ce8a0 | 6360 | // enter calibration mode |
mjr | 38:091e511ce8a0 | 6361 | calBtnState = 3; |
mjr | 52:8298b2a73eb2 | 6362 | plungerReader.setCalMode(true); |
mjr | 38:091e511ce8a0 | 6363 | calBtnTimer.reset(); |
mjr | 39:b3815a1c3802 | 6364 | break; |
mjr | 39:b3815a1c3802 | 6365 | |
mjr | 39:b3815a1c3802 | 6366 | case 3: |
mjr | 52:8298b2a73eb2 | 6367 | // 3 = plunger sensor status report |
mjr | 48:058ace2aed1d | 6368 | // data[2] = flag bits |
mjr | 53:9b2611964afc | 6369 | // data[3] = extra exposure time, 100us (.1ms) increments |
mjr | 52:8298b2a73eb2 | 6370 | reportPlungerStat = true; |
mjr | 53:9b2611964afc | 6371 | reportPlungerStatFlags = data[2]; |
mjr | 53:9b2611964afc | 6372 | reportPlungerStatTime = data[3]; |
mjr | 38:091e511ce8a0 | 6373 | |
mjr | 101:755f44622abc | 6374 | // set the extra integration time in the sensor |
mjr | 101:755f44622abc | 6375 | plungerSensor->setExtraIntegrationTime(reportPlungerStatTime * 100); |
mjr | 101:755f44622abc | 6376 | |
mjr | 101:755f44622abc | 6377 | // make a note of the request timestamp |
mjr | 101:755f44622abc | 6378 | tReportPlungerStat = requestTimestamper.read_us(); |
mjr | 101:755f44622abc | 6379 | |
mjr | 38:091e511ce8a0 | 6380 | // show purple until we finish sending the report |
mjr | 38:091e511ce8a0 | 6381 | diagLED(1, 0, 1); |
mjr | 39:b3815a1c3802 | 6382 | break; |
mjr | 39:b3815a1c3802 | 6383 | |
mjr | 39:b3815a1c3802 | 6384 | case 4: |
mjr | 38:091e511ce8a0 | 6385 | // 4 = hardware configuration query |
mjr | 38:091e511ce8a0 | 6386 | // (No parameters) |
mjr | 38:091e511ce8a0 | 6387 | js.reportConfig( |
mjr | 38:091e511ce8a0 | 6388 | numOutputs, |
mjr | 38:091e511ce8a0 | 6389 | cfg.psUnitNo - 1, // report 0-15 range for unit number (we store 1-16 internally) |
mjr | 52:8298b2a73eb2 | 6390 | cfg.plunger.cal.zero, cfg.plunger.cal.max, cfg.plunger.cal.tRelease, |
mjr | 75:677892300e7a | 6391 | nvm.valid(), // a config is loaded if the config memory block is valid |
mjr | 75:677892300e7a | 6392 | true, // we support sbx/pbx extensions |
mjr | 78:1e00b3fa11af | 6393 | true, // we support the new accelerometer settings |
mjr | 82:4f6209cb5c33 | 6394 | true, // we support the "flash write ok" status bit in joystick reports |
mjr | 92:f264fbaa1be5 | 6395 | true, // we support the configurable joystick report timing features |
mjr | 99:8139b0c274f4 | 6396 | true, // chime logic is supported |
mjr | 79:682ae3171a08 | 6397 | mallocBytesFree()); // remaining memory size |
mjr | 39:b3815a1c3802 | 6398 | break; |
mjr | 39:b3815a1c3802 | 6399 | |
mjr | 39:b3815a1c3802 | 6400 | case 5: |
mjr | 38:091e511ce8a0 | 6401 | // 5 = all outputs off, reset to LedWiz defaults |
mjr | 38:091e511ce8a0 | 6402 | allOutputsOff(); |
mjr | 39:b3815a1c3802 | 6403 | break; |
mjr | 39:b3815a1c3802 | 6404 | |
mjr | 39:b3815a1c3802 | 6405 | case 6: |
mjr | 85:3c28aee81cde | 6406 | // 6 = Save configuration to flash. Optionally reboot after the |
mjr | 85:3c28aee81cde | 6407 | // delay time in seconds given in data[2]. |
mjr | 85:3c28aee81cde | 6408 | // |
mjr | 85:3c28aee81cde | 6409 | // data[2] = delay time in seconds |
mjr | 85:3c28aee81cde | 6410 | // data[3] = flags: |
mjr | 85:3c28aee81cde | 6411 | // 0x01 -> do not reboot |
mjr | 86:e30a1f60f783 | 6412 | saveConfigToFlash(data[2], !(data[3] & 0x01)); |
mjr | 39:b3815a1c3802 | 6413 | break; |
mjr | 40:cc0d9814522b | 6414 | |
mjr | 40:cc0d9814522b | 6415 | case 7: |
mjr | 40:cc0d9814522b | 6416 | // 7 = Device ID report |
mjr | 53:9b2611964afc | 6417 | // data[2] = ID index: 1=CPU ID, 2=OpenSDA TUID |
mjr | 53:9b2611964afc | 6418 | js.reportID(data[2]); |
mjr | 40:cc0d9814522b | 6419 | break; |
mjr | 40:cc0d9814522b | 6420 | |
mjr | 40:cc0d9814522b | 6421 | case 8: |
mjr | 40:cc0d9814522b | 6422 | // 8 = Engage/disengage night mode. |
mjr | 40:cc0d9814522b | 6423 | // data[2] = 1 to engage, 0 to disengage |
mjr | 40:cc0d9814522b | 6424 | setNightMode(data[2]); |
mjr | 40:cc0d9814522b | 6425 | break; |
mjr | 52:8298b2a73eb2 | 6426 | |
mjr | 52:8298b2a73eb2 | 6427 | case 9: |
mjr | 52:8298b2a73eb2 | 6428 | // 9 = Config variable query. |
mjr | 52:8298b2a73eb2 | 6429 | // data[2] = config var ID |
mjr | 52:8298b2a73eb2 | 6430 | // data[3] = array index (for array vars: button assignments, output ports) |
mjr | 52:8298b2a73eb2 | 6431 | { |
mjr | 53:9b2611964afc | 6432 | // set up the reply buffer with the variable ID data, and zero out |
mjr | 53:9b2611964afc | 6433 | // the rest of the buffer |
mjr | 52:8298b2a73eb2 | 6434 | uint8_t reply[8]; |
mjr | 52:8298b2a73eb2 | 6435 | reply[1] = data[2]; |
mjr | 52:8298b2a73eb2 | 6436 | reply[2] = data[3]; |
mjr | 53:9b2611964afc | 6437 | memset(reply+3, 0, sizeof(reply)-3); |
mjr | 52:8298b2a73eb2 | 6438 | |
mjr | 52:8298b2a73eb2 | 6439 | // query the value |
mjr | 52:8298b2a73eb2 | 6440 | configVarGet(reply); |
mjr | 52:8298b2a73eb2 | 6441 | |
mjr | 52:8298b2a73eb2 | 6442 | // send the reply |
mjr | 52:8298b2a73eb2 | 6443 | js.reportConfigVar(reply + 1); |
mjr | 52:8298b2a73eb2 | 6444 | } |
mjr | 52:8298b2a73eb2 | 6445 | break; |
mjr | 53:9b2611964afc | 6446 | |
mjr | 53:9b2611964afc | 6447 | case 10: |
mjr | 53:9b2611964afc | 6448 | // 10 = Build ID query. |
mjr | 53:9b2611964afc | 6449 | js.reportBuildInfo(getBuildID()); |
mjr | 53:9b2611964afc | 6450 | break; |
mjr | 73:4e8ce0b18915 | 6451 | |
mjr | 73:4e8ce0b18915 | 6452 | case 11: |
mjr | 73:4e8ce0b18915 | 6453 | // 11 = TV ON relay control. |
mjr | 73:4e8ce0b18915 | 6454 | // data[2] = operation: |
mjr | 73:4e8ce0b18915 | 6455 | // 0 = turn relay off |
mjr | 73:4e8ce0b18915 | 6456 | // 1 = turn relay on |
mjr | 73:4e8ce0b18915 | 6457 | // 2 = pulse relay (as though the power-on timer fired) |
mjr | 73:4e8ce0b18915 | 6458 | TVRelay(data[2]); |
mjr | 73:4e8ce0b18915 | 6459 | break; |
mjr | 73:4e8ce0b18915 | 6460 | |
mjr | 73:4e8ce0b18915 | 6461 | case 12: |
mjr | 77:0b96f6867312 | 6462 | // 12 = Learn IR code. This enters IR learning mode. While |
mjr | 77:0b96f6867312 | 6463 | // in learning mode, we report raw IR signals and the first IR |
mjr | 77:0b96f6867312 | 6464 | // command decoded through the special IR report format. IR |
mjr | 77:0b96f6867312 | 6465 | // learning mode automatically ends after a timeout expires if |
mjr | 77:0b96f6867312 | 6466 | // no command can be decoded within the time limit. |
mjr | 77:0b96f6867312 | 6467 | |
mjr | 77:0b96f6867312 | 6468 | // enter IR learning mode |
mjr | 77:0b96f6867312 | 6469 | IRLearningMode = 1; |
mjr | 77:0b96f6867312 | 6470 | |
mjr | 77:0b96f6867312 | 6471 | // cancel any regular IR input in progress |
mjr | 77:0b96f6867312 | 6472 | IRCommandIn = 0; |
mjr | 77:0b96f6867312 | 6473 | |
mjr | 77:0b96f6867312 | 6474 | // reset and start the learning mode timeout timer |
mjr | 77:0b96f6867312 | 6475 | IRTimer.reset(); |
mjr | 73:4e8ce0b18915 | 6476 | break; |
mjr | 73:4e8ce0b18915 | 6477 | |
mjr | 73:4e8ce0b18915 | 6478 | case 13: |
mjr | 73:4e8ce0b18915 | 6479 | // 13 = Send button status report |
mjr | 73:4e8ce0b18915 | 6480 | reportButtonStatus(js); |
mjr | 73:4e8ce0b18915 | 6481 | break; |
mjr | 78:1e00b3fa11af | 6482 | |
mjr | 78:1e00b3fa11af | 6483 | case 14: |
mjr | 78:1e00b3fa11af | 6484 | // 14 = manually center the accelerometer |
mjr | 78:1e00b3fa11af | 6485 | accel.manualCenterRequest(); |
mjr | 78:1e00b3fa11af | 6486 | break; |
mjr | 78:1e00b3fa11af | 6487 | |
mjr | 78:1e00b3fa11af | 6488 | case 15: |
mjr | 78:1e00b3fa11af | 6489 | // 15 = set up ad hoc IR command, part 1. Mark the command |
mjr | 78:1e00b3fa11af | 6490 | // as not ready, and save the partial data from the message. |
mjr | 78:1e00b3fa11af | 6491 | IRAdHocCmd.ready = 0; |
mjr | 78:1e00b3fa11af | 6492 | IRAdHocCmd.protocol = data[2]; |
mjr | 78:1e00b3fa11af | 6493 | IRAdHocCmd.dittos = (data[3] & IRFlagDittos) != 0; |
mjr | 78:1e00b3fa11af | 6494 | IRAdHocCmd.code = wireUI32(&data[4]); |
mjr | 78:1e00b3fa11af | 6495 | break; |
mjr | 78:1e00b3fa11af | 6496 | |
mjr | 78:1e00b3fa11af | 6497 | case 16: |
mjr | 78:1e00b3fa11af | 6498 | // 16 = send ad hoc IR command, part 2. Fill in the rest |
mjr | 78:1e00b3fa11af | 6499 | // of the data from the message and mark the command as |
mjr | 78:1e00b3fa11af | 6500 | // ready. The IR polling routine will send this as soon |
mjr | 78:1e00b3fa11af | 6501 | // as the IR transmitter is free. |
mjr | 78:1e00b3fa11af | 6502 | IRAdHocCmd.code |= (uint64_t(wireUI32(&data[2])) << 32); |
mjr | 78:1e00b3fa11af | 6503 | IRAdHocCmd.ready = 1; |
mjr | 78:1e00b3fa11af | 6504 | break; |
mjr | 88:98bce687e6c0 | 6505 | |
mjr | 88:98bce687e6c0 | 6506 | case 17: |
mjr | 88:98bce687e6c0 | 6507 | // 17 = send pre-programmed IR command. This works just like |
mjr | 88:98bce687e6c0 | 6508 | // sending an ad hoc command above, but we get the command data |
mjr | 88:98bce687e6c0 | 6509 | // from an IR slot in the config rather than from the client. |
mjr | 88:98bce687e6c0 | 6510 | // First make sure we have a valid slot number. |
mjr | 88:98bce687e6c0 | 6511 | if (data[2] >= 1 && data[2] <= MAX_IR_CODES) |
mjr | 88:98bce687e6c0 | 6512 | { |
mjr | 88:98bce687e6c0 | 6513 | // get the IR command slot in the config |
mjr | 88:98bce687e6c0 | 6514 | IRCommandCfg &cmd = cfg.IRCommand[data[2] - 1]; |
mjr | 88:98bce687e6c0 | 6515 | |
mjr | 88:98bce687e6c0 | 6516 | // copy the IR command data from the config |
mjr | 88:98bce687e6c0 | 6517 | IRAdHocCmd.protocol = cmd.protocol; |
mjr | 88:98bce687e6c0 | 6518 | IRAdHocCmd.dittos = (cmd.flags & IRFlagDittos) != 0; |
mjr | 88:98bce687e6c0 | 6519 | IRAdHocCmd.code = (uint64_t(cmd.code.hi) << 32) | cmd.code.lo; |
mjr | 88:98bce687e6c0 | 6520 | |
mjr | 88:98bce687e6c0 | 6521 | // mark the command as ready - this will trigger the polling |
mjr | 88:98bce687e6c0 | 6522 | // routine to send the command as soon as the transmitter |
mjr | 88:98bce687e6c0 | 6523 | // is free |
mjr | 88:98bce687e6c0 | 6524 | IRAdHocCmd.ready = 1; |
mjr | 88:98bce687e6c0 | 6525 | } |
mjr | 88:98bce687e6c0 | 6526 | break; |
mjr | 38:091e511ce8a0 | 6527 | } |
mjr | 38:091e511ce8a0 | 6528 | } |
mjr | 38:091e511ce8a0 | 6529 | else if (data[0] == 66) |
mjr | 38:091e511ce8a0 | 6530 | { |
mjr | 38:091e511ce8a0 | 6531 | // Extended protocol - Set configuration variable. |
mjr | 38:091e511ce8a0 | 6532 | // The second byte of the message is the ID of the variable |
mjr | 38:091e511ce8a0 | 6533 | // to update, and the remaining bytes give the new value, |
mjr | 38:091e511ce8a0 | 6534 | // in a variable-dependent format. |
mjr | 40:cc0d9814522b | 6535 | configVarSet(data); |
mjr | 86:e30a1f60f783 | 6536 | |
mjr | 87:8d35c74403af | 6537 | // notify the plunger, so that it can update relevant variables |
mjr | 87:8d35c74403af | 6538 | // dynamically |
mjr | 87:8d35c74403af | 6539 | plungerSensor->onConfigChange(data[1], cfg); |
mjr | 38:091e511ce8a0 | 6540 | } |
mjr | 74:822a92bc11d2 | 6541 | else if (data[0] == 67) |
mjr | 74:822a92bc11d2 | 6542 | { |
mjr | 74:822a92bc11d2 | 6543 | // SBX - extended SBA message. This is the same as SBA, except |
mjr | 74:822a92bc11d2 | 6544 | // that the 7th byte selects a group of 32 ports, to allow access |
mjr | 74:822a92bc11d2 | 6545 | // to ports beyond the first 32. |
mjr | 74:822a92bc11d2 | 6546 | sba_sbx(data[6], data); |
mjr | 74:822a92bc11d2 | 6547 | } |
mjr | 74:822a92bc11d2 | 6548 | else if (data[0] == 68) |
mjr | 74:822a92bc11d2 | 6549 | { |
mjr | 74:822a92bc11d2 | 6550 | // PBX - extended PBA message. This is similar to PBA, but |
mjr | 74:822a92bc11d2 | 6551 | // allows access to more than the first 32 ports by encoding |
mjr | 74:822a92bc11d2 | 6552 | // a port group byte that selects a block of 8 ports. |
mjr | 74:822a92bc11d2 | 6553 | |
mjr | 74:822a92bc11d2 | 6554 | // get the port group - the first port is 8*group |
mjr | 74:822a92bc11d2 | 6555 | int portGroup = data[1]; |
mjr | 74:822a92bc11d2 | 6556 | |
mjr | 74:822a92bc11d2 | 6557 | // unpack the brightness values |
mjr | 74:822a92bc11d2 | 6558 | uint32_t tmp1 = data[2] | (data[3]<<8) | (data[4]<<16); |
mjr | 74:822a92bc11d2 | 6559 | uint32_t tmp2 = data[5] | (data[6]<<8) | (data[7]<<16); |
mjr | 74:822a92bc11d2 | 6560 | uint8_t bri[8] = { |
mjr | 74:822a92bc11d2 | 6561 | tmp1 & 0x3F, (tmp1>>6) & 0x3F, (tmp1>>12) & 0x3F, (tmp1>>18) & 0x3F, |
mjr | 74:822a92bc11d2 | 6562 | tmp2 & 0x3F, (tmp2>>6) & 0x3F, (tmp2>>12) & 0x3F, (tmp2>>18) & 0x3F |
mjr | 74:822a92bc11d2 | 6563 | }; |
mjr | 74:822a92bc11d2 | 6564 | |
mjr | 74:822a92bc11d2 | 6565 | // map the flash levels: 60->129, 61->130, 62->131, 63->132 |
mjr | 74:822a92bc11d2 | 6566 | for (int i = 0 ; i < 8 ; ++i) |
mjr | 74:822a92bc11d2 | 6567 | { |
mjr | 74:822a92bc11d2 | 6568 | if (bri[i] >= 60) |
mjr | 74:822a92bc11d2 | 6569 | bri[i] += 129-60; |
mjr | 74:822a92bc11d2 | 6570 | } |
mjr | 74:822a92bc11d2 | 6571 | |
mjr | 74:822a92bc11d2 | 6572 | // Carry out the PBA |
mjr | 74:822a92bc11d2 | 6573 | pba_pbx(portGroup*8, bri); |
mjr | 74:822a92bc11d2 | 6574 | } |
mjr | 38:091e511ce8a0 | 6575 | else if (data[0] >= 200 && data[0] <= 228) |
mjr | 38:091e511ce8a0 | 6576 | { |
mjr | 38:091e511ce8a0 | 6577 | // Extended protocol - Extended output port brightness update. |
mjr | 38:091e511ce8a0 | 6578 | // data[0]-200 gives us the bank of 7 outputs we're setting: |
mjr | 38:091e511ce8a0 | 6579 | // 200 is outputs 0-6, 201 is outputs 7-13, 202 is 14-20, etc. |
mjr | 38:091e511ce8a0 | 6580 | // The remaining bytes are brightness levels, 0-255, for the |
mjr | 38:091e511ce8a0 | 6581 | // seven outputs in the selected bank. The LedWiz flashing |
mjr | 38:091e511ce8a0 | 6582 | // modes aren't accessible in this message type; we can only |
mjr | 38:091e511ce8a0 | 6583 | // set a fixed brightness, but in exchange we get 8-bit |
mjr | 38:091e511ce8a0 | 6584 | // resolution rather than the paltry 0-48 scale that the real |
mjr | 38:091e511ce8a0 | 6585 | // LedWiz uses. There's no separate on/off status for outputs |
mjr | 38:091e511ce8a0 | 6586 | // adjusted with this message type, either, as there would be |
mjr | 38:091e511ce8a0 | 6587 | // for a PBA message - setting a non-zero value immediately |
mjr | 38:091e511ce8a0 | 6588 | // turns the output, overriding the last SBA setting. |
mjr | 38:091e511ce8a0 | 6589 | // |
mjr | 38:091e511ce8a0 | 6590 | // For outputs 0-31, this overrides any previous PBA/SBA |
mjr | 38:091e511ce8a0 | 6591 | // settings for the port. Any subsequent PBA/SBA message will |
mjr | 38:091e511ce8a0 | 6592 | // in turn override the setting made here. It's simple - the |
mjr | 38:091e511ce8a0 | 6593 | // most recent message of either type takes precedence. For |
mjr | 38:091e511ce8a0 | 6594 | // outputs above the LedWiz range, PBA/SBA messages can't |
mjr | 38:091e511ce8a0 | 6595 | // address those ports anyway. |
mjr | 63:5cd1a5f3a41b | 6596 | |
mjr | 63:5cd1a5f3a41b | 6597 | // figure the block of 7 ports covered in the message |
mjr | 38:091e511ce8a0 | 6598 | int i0 = (data[0] - 200)*7; |
mjr | 38:091e511ce8a0 | 6599 | int i1 = i0 + 7 < numOutputs ? i0 + 7 : numOutputs; |
mjr | 63:5cd1a5f3a41b | 6600 | |
mjr | 63:5cd1a5f3a41b | 6601 | // update each port |
mjr | 38:091e511ce8a0 | 6602 | for (int i = i0 ; i < i1 ; ++i) |
mjr | 38:091e511ce8a0 | 6603 | { |
mjr | 38:091e511ce8a0 | 6604 | // set the brightness level for the output |
mjr | 40:cc0d9814522b | 6605 | uint8_t b = data[i-i0+1]; |
mjr | 38:091e511ce8a0 | 6606 | outLevel[i] = b; |
mjr | 38:091e511ce8a0 | 6607 | |
mjr | 74:822a92bc11d2 | 6608 | // set the port's LedWiz state to the nearest equivalent, so |
mjr | 74:822a92bc11d2 | 6609 | // that it maintains its current setting if we switch back to |
mjr | 74:822a92bc11d2 | 6610 | // LedWiz mode on a future update |
mjr | 76:7f5912b6340e | 6611 | if (b != 0) |
mjr | 76:7f5912b6340e | 6612 | { |
mjr | 76:7f5912b6340e | 6613 | // Non-zero brightness - set the SBA switch on, and set the |
mjr | 76:7f5912b6340e | 6614 | // PBA brightness to the DOF brightness rescaled to the 1..48 |
mjr | 76:7f5912b6340e | 6615 | // LedWiz range. If the port is subsequently addressed by an |
mjr | 76:7f5912b6340e | 6616 | // LedWiz command, this will carry the current DOF setting |
mjr | 76:7f5912b6340e | 6617 | // forward unchanged. |
mjr | 76:7f5912b6340e | 6618 | wizOn[i] = 1; |
mjr | 76:7f5912b6340e | 6619 | wizVal[i] = dof_to_lw[b]; |
mjr | 76:7f5912b6340e | 6620 | } |
mjr | 76:7f5912b6340e | 6621 | else |
mjr | 76:7f5912b6340e | 6622 | { |
mjr | 76:7f5912b6340e | 6623 | // Zero brightness. Set the SBA switch off, and leave the |
mjr | 76:7f5912b6340e | 6624 | // PBA brightness the same as it was. |
mjr | 76:7f5912b6340e | 6625 | wizOn[i] = 0; |
mjr | 76:7f5912b6340e | 6626 | } |
mjr | 74:822a92bc11d2 | 6627 | |
mjr | 38:091e511ce8a0 | 6628 | // set the output |
mjr | 40:cc0d9814522b | 6629 | lwPin[i]->set(b); |
mjr | 38:091e511ce8a0 | 6630 | } |
mjr | 38:091e511ce8a0 | 6631 | |
mjr | 38:091e511ce8a0 | 6632 | // update 74HC595 outputs, if attached |
mjr | 38:091e511ce8a0 | 6633 | if (hc595 != 0) |
mjr | 38:091e511ce8a0 | 6634 | hc595->update(); |
mjr | 38:091e511ce8a0 | 6635 | } |
mjr | 38:091e511ce8a0 | 6636 | else |
mjr | 38:091e511ce8a0 | 6637 | { |
mjr | 74:822a92bc11d2 | 6638 | // Everything else is an LedWiz PBA message. This is a full |
mjr | 74:822a92bc11d2 | 6639 | // "profile" dump from the host for one bank of 8 outputs. Each |
mjr | 74:822a92bc11d2 | 6640 | // byte sets one output in the current bank. The current bank |
mjr | 74:822a92bc11d2 | 6641 | // is implied; the bank starts at 0 and is reset to 0 by any SBA |
mjr | 74:822a92bc11d2 | 6642 | // message, and is incremented to the next bank by each PBA. Our |
mjr | 74:822a92bc11d2 | 6643 | // variable pbaIdx keeps track of the current bank. There's no |
mjr | 74:822a92bc11d2 | 6644 | // direct way for the host to select the bank; it just has to count |
mjr | 74:822a92bc11d2 | 6645 | // on us staying in sync. In practice, clients always send the |
mjr | 74:822a92bc11d2 | 6646 | // full set of 4 PBA messages in a row to set all 32 outputs. |
mjr | 38:091e511ce8a0 | 6647 | // |
mjr | 38:091e511ce8a0 | 6648 | // Note that a PBA implicitly overrides our extended profile |
mjr | 38:091e511ce8a0 | 6649 | // messages (message prefix 200-219), because this sets the |
mjr | 38:091e511ce8a0 | 6650 | // wizVal[] entry for each output, and that takes precedence |
mjr | 63:5cd1a5f3a41b | 6651 | // over the extended protocol settings when we're in LedWiz |
mjr | 63:5cd1a5f3a41b | 6652 | // protocol mode. |
mjr | 38:091e511ce8a0 | 6653 | // |
mjr | 38:091e511ce8a0 | 6654 | //printf("LWZ-PBA[%d] %02x %02x %02x %02x %02x %02x %02x %02x\r\n", |
mjr | 38:091e511ce8a0 | 6655 | // pbaIdx, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); |
mjr | 38:091e511ce8a0 | 6656 | |
mjr | 74:822a92bc11d2 | 6657 | // carry out the PBA |
mjr | 74:822a92bc11d2 | 6658 | pba_pbx(pbaIdx, data); |
mjr | 74:822a92bc11d2 | 6659 | |
mjr | 74:822a92bc11d2 | 6660 | // update the PBX index state for the next message |
mjr | 74:822a92bc11d2 | 6661 | pbaIdx = (pbaIdx + 8) % 32; |
mjr | 38:091e511ce8a0 | 6662 | } |
mjr | 38:091e511ce8a0 | 6663 | } |
mjr | 35:e959ffba78fd | 6664 | |
mjr | 38:091e511ce8a0 | 6665 | // --------------------------------------------------------------------------- |
mjr | 38:091e511ce8a0 | 6666 | // |
mjr | 5:a70c0bce770d | 6667 | // Main program loop. This is invoked on startup and runs forever. Our |
mjr | 5:a70c0bce770d | 6668 | // main work is to read our devices (the accelerometer and the CCD), process |
mjr | 5:a70c0bce770d | 6669 | // the readings into nudge and plunger position data, and send the results |
mjr | 5:a70c0bce770d | 6670 | // to the host computer via the USB joystick interface. We also monitor |
mjr | 5:a70c0bce770d | 6671 | // the USB connection for incoming LedWiz commands and process those into |
mjr | 5:a70c0bce770d | 6672 | // port outputs. |
mjr | 5:a70c0bce770d | 6673 | // |
mjr | 0:5acbbe3f4cf4 | 6674 | int main(void) |
mjr | 0:5acbbe3f4cf4 | 6675 | { |
mjr | 60:f38da020aa13 | 6676 | // say hello to the debug console, in case it's connected |
mjr | 39:b3815a1c3802 | 6677 | printf("\r\nPinscape Controller starting\r\n"); |
mjr | 94:0476b3e2b996 | 6678 | |
mjr | 98:4df3c0f7e707 | 6679 | // Set the default PWM period to 0.5ms = 2 kHz. This will be used |
mjr | 98:4df3c0f7e707 | 6680 | // for PWM channels on PWM units whose periods aren't changed |
mjr | 98:4df3c0f7e707 | 6681 | // explicitly, so it'll apply to LW outputs assigned to GPIO pins. |
mjr | 98:4df3c0f7e707 | 6682 | // The KL25Z only allows the period to be set at the TPM unit |
mjr | 94:0476b3e2b996 | 6683 | // level, not per channel, so all channels on a given unit will |
mjr | 94:0476b3e2b996 | 6684 | // necessarily use the same frequency. We (currently) have two |
mjr | 94:0476b3e2b996 | 6685 | // subsystems that need specific PWM frequencies: TLC5940NT (which |
mjr | 94:0476b3e2b996 | 6686 | // uses PWM to generate the grayscale clock signal) and IR remote |
mjr | 94:0476b3e2b996 | 6687 | // (which uses PWM to generate the IR carrier signal). Since |
mjr | 94:0476b3e2b996 | 6688 | // those require specific PWM frequencies, it's important to assign |
mjr | 94:0476b3e2b996 | 6689 | // those to separate TPM units if both are in use simultaneously; |
mjr | 94:0476b3e2b996 | 6690 | // the Config Tool includes checks to ensure that will happen when |
mjr | 94:0476b3e2b996 | 6691 | // setting a config interactively. In addition, for the greatest |
mjr | 94:0476b3e2b996 | 6692 | // flexibility, we take care NOT to assign explicit PWM frequencies |
mjr | 94:0476b3e2b996 | 6693 | // to pins that don't require special frequences. That way, if a |
mjr | 94:0476b3e2b996 | 6694 | // pin that doesn't need anything special happens to be sharing a |
mjr | 94:0476b3e2b996 | 6695 | // TPM unit with a pin that does require a specific frequency, the |
mjr | 94:0476b3e2b996 | 6696 | // two will co-exist peacefully on the TPM. |
mjr | 94:0476b3e2b996 | 6697 | // |
mjr | 94:0476b3e2b996 | 6698 | // We set this default first, before we create any PWM GPIOs, so |
mjr | 94:0476b3e2b996 | 6699 | // that it will apply to all channels by default but won't override |
mjr | 94:0476b3e2b996 | 6700 | // any channels that need specific frequences. Currently, the only |
mjr | 94:0476b3e2b996 | 6701 | // frequency-agnostic PWM user is the LW outputs, so we can choose |
mjr | 94:0476b3e2b996 | 6702 | // the default to be suitable for those. This is chosen to minimize |
mjr | 94:0476b3e2b996 | 6703 | // flicker on attached LEDs. |
mjr | 94:0476b3e2b996 | 6704 | NewPwmUnit::defaultPeriod = 0.0005f; |
mjr | 82:4f6209cb5c33 | 6705 | |
mjr | 76:7f5912b6340e | 6706 | // clear the I2C connection |
mjr | 112:8ed709f455c0 | 6707 | Accel::clear_i2c(); |
mjr | 82:4f6209cb5c33 | 6708 | |
mjr | 82:4f6209cb5c33 | 6709 | // Elevate GPIO pin interrupt priorities, so that they can preempt |
mjr | 82:4f6209cb5c33 | 6710 | // other interrupts. This is important for some external peripherals, |
mjr | 82:4f6209cb5c33 | 6711 | // particularly the quadrature plunger sensors, which can generate |
mjr | 82:4f6209cb5c33 | 6712 | // high-speed interrupts that need to be serviced quickly to keep |
mjr | 82:4f6209cb5c33 | 6713 | // proper count of the quadrature position. |
mjr | 82:4f6209cb5c33 | 6714 | FastInterruptIn::elevatePriority(); |
mjr | 38:091e511ce8a0 | 6715 | |
mjr | 76:7f5912b6340e | 6716 | // Load the saved configuration. There are two sources of the |
mjr | 76:7f5912b6340e | 6717 | // configuration data: |
mjr | 76:7f5912b6340e | 6718 | // |
mjr | 76:7f5912b6340e | 6719 | // - Look for an NVM (flash non-volatile memory) configuration. |
mjr | 76:7f5912b6340e | 6720 | // If this is valid, we'll load it. The NVM is config data that can |
mjr | 76:7f5912b6340e | 6721 | // be updated dynamically by the host via USB commands and then stored |
mjr | 76:7f5912b6340e | 6722 | // in the flash by the firmware itself. If this exists, it supersedes |
mjr | 76:7f5912b6340e | 6723 | // any of the other settings stores. The Windows config tool uses this |
mjr | 76:7f5912b6340e | 6724 | // to store user settings updates. |
mjr | 76:7f5912b6340e | 6725 | // |
mjr | 76:7f5912b6340e | 6726 | // - If there's no NVM, we'll load the factory defaults, then we'll |
mjr | 76:7f5912b6340e | 6727 | // load any settings stored in the host-loaded configuration. The |
mjr | 76:7f5912b6340e | 6728 | // host can patch a set of configuration variable settings into the |
mjr | 76:7f5912b6340e | 6729 | // .bin file when loading new firmware, in the host-loaded config |
mjr | 76:7f5912b6340e | 6730 | // area that we reserve for this purpose. This allows the host to |
mjr | 76:7f5912b6340e | 6731 | // restore a configuration at the same time it installs firmware, |
mjr | 76:7f5912b6340e | 6732 | // without a separate download of the config data. |
mjr | 76:7f5912b6340e | 6733 | // |
mjr | 76:7f5912b6340e | 6734 | // The NVM supersedes the host-loaded config, since it can be updated |
mjr | 76:7f5912b6340e | 6735 | // between firmware updated and is thus presumably more recent if it's |
mjr | 76:7f5912b6340e | 6736 | // present. (Note that the NVM and host-loaded config are both in |
mjr | 76:7f5912b6340e | 6737 | // flash, so in principle we could just have a single NVM store that |
mjr | 76:7f5912b6340e | 6738 | // the host patches. The only reason we don't is that the NVM store |
mjr | 76:7f5912b6340e | 6739 | // is an image of our in-memory config structure, which is a native C |
mjr | 76:7f5912b6340e | 6740 | // struct, and we don't want the host to have to know the details of |
mjr | 76:7f5912b6340e | 6741 | // its byte layout, for obvious reasons. The host-loaded config, in |
mjr | 76:7f5912b6340e | 6742 | // contrast, uses the wire protocol format, which has a well-defined |
mjr | 76:7f5912b6340e | 6743 | // byte layout that's independent of the firmware version or the |
mjr | 76:7f5912b6340e | 6744 | // details of how the C compiler arranges the struct memory.) |
mjr | 76:7f5912b6340e | 6745 | if (!loadConfigFromFlash()) |
mjr | 76:7f5912b6340e | 6746 | loadHostLoadedConfig(); |
mjr | 35:e959ffba78fd | 6747 | |
mjr | 38:091e511ce8a0 | 6748 | // initialize the diagnostic LEDs |
mjr | 38:091e511ce8a0 | 6749 | initDiagLEDs(cfg); |
mjr | 38:091e511ce8a0 | 6750 | |
mjr | 33:d832bcab089e | 6751 | // we're not connected/awake yet |
mjr | 33:d832bcab089e | 6752 | bool connected = false; |
mjr | 40:cc0d9814522b | 6753 | Timer connectChangeTimer; |
mjr | 33:d832bcab089e | 6754 | |
mjr | 35:e959ffba78fd | 6755 | // create the plunger sensor interface |
mjr | 35:e959ffba78fd | 6756 | createPlunger(); |
mjr | 76:7f5912b6340e | 6757 | |
mjr | 76:7f5912b6340e | 6758 | // update the plunger reader's cached calibration data |
mjr | 76:7f5912b6340e | 6759 | plungerReader.onUpdateCal(); |
mjr | 33:d832bcab089e | 6760 | |
mjr | 60:f38da020aa13 | 6761 | // set up the TLC5940 interface, if these chips are present |
mjr | 35:e959ffba78fd | 6762 | init_tlc5940(cfg); |
mjr | 34:6b981a2afab7 | 6763 | |
mjr | 87:8d35c74403af | 6764 | // initialize the TLC5916 interface, if these chips are present |
mjr | 87:8d35c74403af | 6765 | init_tlc59116(cfg); |
mjr | 87:8d35c74403af | 6766 | |
mjr | 60:f38da020aa13 | 6767 | // set up 74HC595 interface, if these chips are present |
mjr | 35:e959ffba78fd | 6768 | init_hc595(cfg); |
mjr | 6:cc35eb643e8f | 6769 | |
mjr | 54:fd77a6b2f76c | 6770 | // Initialize the LedWiz ports. Note that the ordering here is important: |
mjr | 54:fd77a6b2f76c | 6771 | // this has to come after we create the TLC5940 and 74HC595 object instances |
mjr | 54:fd77a6b2f76c | 6772 | // (which we just did above), since we need to access those objects to set |
mjr | 54:fd77a6b2f76c | 6773 | // up ports assigned to the respective chips. |
mjr | 35:e959ffba78fd | 6774 | initLwOut(cfg); |
mjr | 48:058ace2aed1d | 6775 | |
mjr | 60:f38da020aa13 | 6776 | // start the TLC5940 refresh cycle clock |
mjr | 35:e959ffba78fd | 6777 | if (tlc5940 != 0) |
mjr | 35:e959ffba78fd | 6778 | tlc5940->start(); |
mjr | 87:8d35c74403af | 6779 | |
mjr | 77:0b96f6867312 | 6780 | // Assume that nothing uses keyboard keys. We'll check for keyboard |
mjr | 77:0b96f6867312 | 6781 | // usage when initializing the various subsystems that can send keys |
mjr | 77:0b96f6867312 | 6782 | // (buttons, IR). If we find anything that does, we'll create the |
mjr | 77:0b96f6867312 | 6783 | // USB keyboard interface. |
mjr | 77:0b96f6867312 | 6784 | bool kbKeys = false; |
mjr | 77:0b96f6867312 | 6785 | |
mjr | 77:0b96f6867312 | 6786 | // set up the IR remote control emitter & receiver, if present |
mjr | 77:0b96f6867312 | 6787 | init_IR(cfg, kbKeys); |
mjr | 77:0b96f6867312 | 6788 | |
mjr | 77:0b96f6867312 | 6789 | // start the power status time, if applicable |
mjr | 77:0b96f6867312 | 6790 | startPowerStatusTimer(cfg); |
mjr | 48:058ace2aed1d | 6791 | |
mjr | 35:e959ffba78fd | 6792 | // initialize the button input ports |
mjr | 35:e959ffba78fd | 6793 | initButtons(cfg, kbKeys); |
mjr | 38:091e511ce8a0 | 6794 | |
mjr | 60:f38da020aa13 | 6795 | // Create the joystick USB client. Note that the USB vendor/product ID |
mjr | 60:f38da020aa13 | 6796 | // information comes from the saved configuration. Also note that we have |
mjr | 60:f38da020aa13 | 6797 | // to wait until after initializing the input buttons (which we just did |
mjr | 60:f38da020aa13 | 6798 | // above) to set up the interface, since the button setup will determine |
mjr | 60:f38da020aa13 | 6799 | // whether or not we need to present a USB keyboard interface in addition |
mjr | 60:f38da020aa13 | 6800 | // to the joystick interface. |
mjr | 51:57eb311faafa | 6801 | MyUSBJoystick js(cfg.usbVendorID, cfg.usbProductID, USB_VERSION_NO, false, |
mjr | 90:aa4e571da8e8 | 6802 | cfg.joystickEnabled, cfg.joystickAxisFormat, kbKeys); |
mjr | 51:57eb311faafa | 6803 | |
mjr | 101:755f44622abc | 6804 | // start the request timestamp timer |
mjr | 101:755f44622abc | 6805 | requestTimestamper.start(); |
mjr | 101:755f44622abc | 6806 | |
mjr | 60:f38da020aa13 | 6807 | // Wait for the USB connection to start up. Show a distinctive diagnostic |
mjr | 60:f38da020aa13 | 6808 | // flash pattern while waiting. |
mjr | 70:9f58735a1732 | 6809 | Timer connTimeoutTimer, connFlashTimer; |
mjr | 70:9f58735a1732 | 6810 | connTimeoutTimer.start(); |
mjr | 70:9f58735a1732 | 6811 | connFlashTimer.start(); |
mjr | 51:57eb311faafa | 6812 | while (!js.configured()) |
mjr | 51:57eb311faafa | 6813 | { |
mjr | 51:57eb311faafa | 6814 | // show one short yellow flash at 2-second intervals |
mjr | 70:9f58735a1732 | 6815 | if (connFlashTimer.read_us() > 2000000) |
mjr | 51:57eb311faafa | 6816 | { |
mjr | 51:57eb311faafa | 6817 | // short yellow flash |
mjr | 51:57eb311faafa | 6818 | diagLED(1, 1, 0); |
mjr | 54:fd77a6b2f76c | 6819 | wait_us(50000); |
mjr | 51:57eb311faafa | 6820 | diagLED(0, 0, 0); |
mjr | 51:57eb311faafa | 6821 | |
mjr | 51:57eb311faafa | 6822 | // reset the flash timer |
mjr | 70:9f58735a1732 | 6823 | connFlashTimer.reset(); |
mjr | 51:57eb311faafa | 6824 | } |
mjr | 70:9f58735a1732 | 6825 | |
mjr | 77:0b96f6867312 | 6826 | // If we've been disconnected for more than the reboot timeout, |
mjr | 77:0b96f6867312 | 6827 | // reboot. Some PCs won't reconnect if we were left plugged in |
mjr | 77:0b96f6867312 | 6828 | // during a power cycle on the PC, but fortunately a reboot on |
mjr | 77:0b96f6867312 | 6829 | // the KL25Z will make the host notice us and trigger a reconnect. |
mjr | 86:e30a1f60f783 | 6830 | // Don't do this if we're in a non-recoverable PSU2 power state. |
mjr | 70:9f58735a1732 | 6831 | if (cfg.disconnectRebootTimeout != 0 |
mjr | 86:e30a1f60f783 | 6832 | && connTimeoutTimer.read() > cfg.disconnectRebootTimeout |
mjr | 86:e30a1f60f783 | 6833 | && powerStatusAllowsReboot()) |
mjr | 70:9f58735a1732 | 6834 | reboot(js, false, 0); |
mjr | 77:0b96f6867312 | 6835 | |
mjr | 77:0b96f6867312 | 6836 | // update the PSU2 power sensing status |
mjr | 77:0b96f6867312 | 6837 | powerStatusUpdate(cfg); |
mjr | 51:57eb311faafa | 6838 | } |
mjr | 60:f38da020aa13 | 6839 | |
mjr | 60:f38da020aa13 | 6840 | // we're now connected to the host |
mjr | 54:fd77a6b2f76c | 6841 | connected = true; |
mjr | 40:cc0d9814522b | 6842 | |
mjr | 92:f264fbaa1be5 | 6843 | // Set up a timer for keeping track of how long it's been since we |
mjr | 92:f264fbaa1be5 | 6844 | // sent the last joystick report. We use this to determine when it's |
mjr | 92:f264fbaa1be5 | 6845 | // time to send the next joystick report. |
mjr | 92:f264fbaa1be5 | 6846 | // |
mjr | 92:f264fbaa1be5 | 6847 | // We have to use a timer for two reasons. The first is that our main |
mjr | 92:f264fbaa1be5 | 6848 | // loop runs too fast (about .25ms to 2.5ms per loop, depending on the |
mjr | 92:f264fbaa1be5 | 6849 | // type of plunger sensor attached and other factors) for us to send |
mjr | 92:f264fbaa1be5 | 6850 | // joystick reports on every iteration. We *could*, but the PC couldn't |
mjr | 92:f264fbaa1be5 | 6851 | // digest them at that pace. So we need to slow down the reports to a |
mjr | 92:f264fbaa1be5 | 6852 | // reasonable pace. The second is that VP has some complicated timing |
mjr | 92:f264fbaa1be5 | 6853 | // issues of its own, so we not only need to slow down the reports from |
mjr | 92:f264fbaa1be5 | 6854 | // our "natural" pace, but also time them to sync up with VP's input |
mjr | 92:f264fbaa1be5 | 6855 | // sampling rate as best we can. |
mjr | 38:091e511ce8a0 | 6856 | Timer jsReportTimer; |
mjr | 38:091e511ce8a0 | 6857 | jsReportTimer.start(); |
mjr | 38:091e511ce8a0 | 6858 | |
mjr | 92:f264fbaa1be5 | 6859 | // Accelerometer sample "stutter" counter. Each time we send a joystick |
mjr | 92:f264fbaa1be5 | 6860 | // report, we increment this counter, and check to see if it has reached |
mjr | 92:f264fbaa1be5 | 6861 | // the threshold set in the configuration. If so, we take a new |
mjr | 92:f264fbaa1be5 | 6862 | // accelerometer sample and send it with the new joystick report. It |
mjr | 92:f264fbaa1be5 | 6863 | // not, we don't take a new sample, but simply repeat the last sample. |
mjr | 92:f264fbaa1be5 | 6864 | // |
mjr | 92:f264fbaa1be5 | 6865 | // This lets us send joystick reports more frequently than accelerometer |
mjr | 92:f264fbaa1be5 | 6866 | // samples. The point is to let us slow down accelerometer reports to |
mjr | 92:f264fbaa1be5 | 6867 | // a pace that matches VP's input sampling frequency, while still sending |
mjr | 92:f264fbaa1be5 | 6868 | // joystick button updates more frequently, so that other programs that |
mjr | 92:f264fbaa1be5 | 6869 | // can read input faster will see button changes with less latency. |
mjr | 92:f264fbaa1be5 | 6870 | int jsAccelStutterCounter = 0; |
mjr | 92:f264fbaa1be5 | 6871 | |
mjr | 92:f264fbaa1be5 | 6872 | // Last accelerometer report, in joystick units. We normally report the |
mjr | 92:f264fbaa1be5 | 6873 | // acceleromter reading via the joystick X and Y axes, per the VP |
mjr | 92:f264fbaa1be5 | 6874 | // convention. We can alternatively report in the RX and RY axes; this |
mjr | 92:f264fbaa1be5 | 6875 | // can be set in the configuration. |
mjr | 92:f264fbaa1be5 | 6876 | int x = 0, y = 0; |
mjr | 92:f264fbaa1be5 | 6877 | |
mjr | 60:f38da020aa13 | 6878 | // Time since we successfully sent a USB report. This is a hacky |
mjr | 60:f38da020aa13 | 6879 | // workaround to deal with any remaining sporadic problems in the USB |
mjr | 60:f38da020aa13 | 6880 | // stack. I've been trying to bulletproof the USB code over time to |
mjr | 60:f38da020aa13 | 6881 | // remove all such problems at their source, but it seems unlikely that |
mjr | 60:f38da020aa13 | 6882 | // we'll ever get them all. Thus this hack. The idea here is that if |
mjr | 60:f38da020aa13 | 6883 | // we go too long without successfully sending a USB report, we'll |
mjr | 60:f38da020aa13 | 6884 | // assume that the connection is broken (and the KL25Z USB hardware |
mjr | 60:f38da020aa13 | 6885 | // hasn't noticed this), and we'll try taking measures to recover. |
mjr | 38:091e511ce8a0 | 6886 | Timer jsOKTimer; |
mjr | 38:091e511ce8a0 | 6887 | jsOKTimer.start(); |
mjr | 35:e959ffba78fd | 6888 | |
mjr | 55:4db125cd11a0 | 6889 | // Initialize the calibration button and lamp, if enabled. To be enabled, |
mjr | 55:4db125cd11a0 | 6890 | // the pin has to be assigned to something other than NC (0xFF), AND the |
mjr | 55:4db125cd11a0 | 6891 | // corresponding feature enable flag has to be set. |
mjr | 55:4db125cd11a0 | 6892 | DigitalIn *calBtn = 0; |
mjr | 55:4db125cd11a0 | 6893 | DigitalOut *calBtnLed = 0; |
mjr | 55:4db125cd11a0 | 6894 | |
mjr | 55:4db125cd11a0 | 6895 | // calibration button input - feature flag 0x01 |
mjr | 55:4db125cd11a0 | 6896 | if ((cfg.plunger.cal.features & 0x01) && cfg.plunger.cal.btn != 0xFF) |
mjr | 55:4db125cd11a0 | 6897 | calBtn = new DigitalIn(wirePinName(cfg.plunger.cal.btn)); |
mjr | 55:4db125cd11a0 | 6898 | |
mjr | 55:4db125cd11a0 | 6899 | // calibration button indicator lamp output - feature flag 0x02 |
mjr | 55:4db125cd11a0 | 6900 | if ((cfg.plunger.cal.features & 0x02) && cfg.plunger.cal.led != 0xFF) |
mjr | 55:4db125cd11a0 | 6901 | calBtnLed = new DigitalOut(wirePinName(cfg.plunger.cal.led)); |
mjr | 6:cc35eb643e8f | 6902 | |
mjr | 35:e959ffba78fd | 6903 | // initialize the calibration button |
mjr | 1:d913e0afb2ac | 6904 | calBtnTimer.start(); |
mjr | 35:e959ffba78fd | 6905 | calBtnState = 0; |
mjr | 1:d913e0afb2ac | 6906 | |
mjr | 1:d913e0afb2ac | 6907 | // set up a timer for our heartbeat indicator |
mjr | 1:d913e0afb2ac | 6908 | Timer hbTimer; |
mjr | 1:d913e0afb2ac | 6909 | hbTimer.start(); |
mjr | 1:d913e0afb2ac | 6910 | int hb = 0; |
mjr | 5:a70c0bce770d | 6911 | uint16_t hbcnt = 0; |
mjr | 1:d913e0afb2ac | 6912 | |
mjr | 1:d913e0afb2ac | 6913 | // set a timer for accelerometer auto-centering |
mjr | 1:d913e0afb2ac | 6914 | Timer acTimer; |
mjr | 1:d913e0afb2ac | 6915 | acTimer.start(); |
mjr | 1:d913e0afb2ac | 6916 | |
mjr | 0:5acbbe3f4cf4 | 6917 | // create the accelerometer object |
mjr | 112:8ed709f455c0 | 6918 | Accel accel(cfg); |
mjr | 76:7f5912b6340e | 6919 | |
mjr | 48:058ace2aed1d | 6920 | // initialize the plunger sensor |
mjr | 35:e959ffba78fd | 6921 | plungerSensor->init(); |
mjr | 10:976666ffa4ef | 6922 | |
mjr | 48:058ace2aed1d | 6923 | // set up the ZB Launch Ball monitor |
mjr | 48:058ace2aed1d | 6924 | ZBLaunchBall zbLaunchBall; |
mjr | 48:058ace2aed1d | 6925 | |
mjr | 54:fd77a6b2f76c | 6926 | // enable the peripheral chips |
mjr | 54:fd77a6b2f76c | 6927 | if (tlc5940 != 0) |
mjr | 54:fd77a6b2f76c | 6928 | tlc5940->enable(true); |
mjr | 54:fd77a6b2f76c | 6929 | if (hc595 != 0) |
mjr | 54:fd77a6b2f76c | 6930 | hc595->enable(true); |
mjr | 87:8d35c74403af | 6931 | if (tlc59116 != 0) |
mjr | 87:8d35c74403af | 6932 | tlc59116->enable(true); |
mjr | 74:822a92bc11d2 | 6933 | |
mjr | 76:7f5912b6340e | 6934 | // start the LedWiz flash cycle timer |
mjr | 74:822a92bc11d2 | 6935 | wizCycleTimer.start(); |
mjr | 74:822a92bc11d2 | 6936 | |
mjr | 74:822a92bc11d2 | 6937 | // start the PWM update polling timer |
mjr | 74:822a92bc11d2 | 6938 | polledPwmTimer.start(); |
mjr | 43:7a6364d82a41 | 6939 | |
mjr | 1:d913e0afb2ac | 6940 | // we're all set up - now just loop, processing sensor reports and |
mjr | 1:d913e0afb2ac | 6941 | // host requests |
mjr | 0:5acbbe3f4cf4 | 6942 | for (;;) |
mjr | 0:5acbbe3f4cf4 | 6943 | { |
mjr | 74:822a92bc11d2 | 6944 | // start the main loop timer for diagnostic data collection |
mjr | 76:7f5912b6340e | 6945 | IF_DIAG(mainLoopTimer.reset(); mainLoopTimer.start();) |
mjr | 96:68d5621ff49f | 6946 | |
mjr | 48:058ace2aed1d | 6947 | // Process incoming reports on the joystick interface. The joystick |
mjr | 48:058ace2aed1d | 6948 | // "out" (receive) endpoint is used for LedWiz commands and our |
mjr | 48:058ace2aed1d | 6949 | // extended protocol commands. Limit processing time to 5ms to |
mjr | 48:058ace2aed1d | 6950 | // ensure we don't starve the input side. |
mjr | 39:b3815a1c3802 | 6951 | LedWizMsg lwm; |
mjr | 48:058ace2aed1d | 6952 | Timer lwt; |
mjr | 48:058ace2aed1d | 6953 | lwt.start(); |
mjr | 77:0b96f6867312 | 6954 | IF_DIAG(int msgCount = 0;) |
mjr | 48:058ace2aed1d | 6955 | while (js.readLedWizMsg(lwm) && lwt.read_us() < 5000) |
mjr | 74:822a92bc11d2 | 6956 | { |
mjr | 78:1e00b3fa11af | 6957 | handleInputMsg(lwm, js, accel); |
mjr | 74:822a92bc11d2 | 6958 | IF_DIAG(++msgCount;) |
mjr | 74:822a92bc11d2 | 6959 | } |
mjr | 74:822a92bc11d2 | 6960 | |
mjr | 74:822a92bc11d2 | 6961 | // collect performance statistics on the message reader, if desired |
mjr | 74:822a92bc11d2 | 6962 | IF_DIAG( |
mjr | 74:822a92bc11d2 | 6963 | if (msgCount != 0) |
mjr | 74:822a92bc11d2 | 6964 | { |
mjr | 76:7f5912b6340e | 6965 | mainLoopMsgTime += lwt.read_us(); |
mjr | 74:822a92bc11d2 | 6966 | mainLoopMsgCount++; |
mjr | 74:822a92bc11d2 | 6967 | } |
mjr | 74:822a92bc11d2 | 6968 | ) |
mjr | 74:822a92bc11d2 | 6969 | |
mjr | 77:0b96f6867312 | 6970 | // process IR input |
mjr | 77:0b96f6867312 | 6971 | process_IR(cfg, js); |
mjr | 77:0b96f6867312 | 6972 | |
mjr | 77:0b96f6867312 | 6973 | // update the PSU2 power sensing status |
mjr | 77:0b96f6867312 | 6974 | powerStatusUpdate(cfg); |
mjr | 77:0b96f6867312 | 6975 | |
mjr | 74:822a92bc11d2 | 6976 | // update flashing LedWiz outputs periodically |
mjr | 74:822a92bc11d2 | 6977 | wizPulse(); |
mjr | 74:822a92bc11d2 | 6978 | |
mjr | 74:822a92bc11d2 | 6979 | // update PWM outputs |
mjr | 74:822a92bc11d2 | 6980 | pollPwmUpdates(); |
mjr | 77:0b96f6867312 | 6981 | |
mjr | 99:8139b0c274f4 | 6982 | // update Flipper Logic and Chime Logic outputs |
mjr | 89:c43cd923401c | 6983 | LwFlipperLogicOut::poll(); |
mjr | 99:8139b0c274f4 | 6984 | LwChimeLogicOut::poll(); |
mjr | 89:c43cd923401c | 6985 | |
mjr | 77:0b96f6867312 | 6986 | // poll the accelerometer |
mjr | 112:8ed709f455c0 | 6987 | if (!accel.poll()) |
mjr | 112:8ed709f455c0 | 6988 | Accel::softReset(&accel, cfg); |
mjr | 55:4db125cd11a0 | 6989 | |
mjr | 96:68d5621ff49f | 6990 | // Note the "effective" plunger enabled status. This has two |
mjr | 96:68d5621ff49f | 6991 | // components: the explicit "enabled" bit, and the plunger sensor |
mjr | 96:68d5621ff49f | 6992 | // type setting. For most purposes, a plunger type of NONE is |
mjr | 96:68d5621ff49f | 6993 | // equivalent to disabled. Set this to explicit 0x01 or 0x00 |
mjr | 96:68d5621ff49f | 6994 | // so that we can OR the bit into status reports. |
mjr | 96:68d5621ff49f | 6995 | uint8_t effectivePlungerEnabled = (cfg.plunger.enabled |
mjr | 96:68d5621ff49f | 6996 | && cfg.plunger.sensorType != PlungerType_None) ? 0x01 : 0x00; |
mjr | 96:68d5621ff49f | 6997 | |
mjr | 76:7f5912b6340e | 6998 | // collect diagnostic statistics, checkpoint 0 |
mjr | 76:7f5912b6340e | 6999 | IF_DIAG(mainLoopIterCheckpt[0] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7000 | |
mjr | 55:4db125cd11a0 | 7001 | // send TLC5940 data updates if applicable |
mjr | 55:4db125cd11a0 | 7002 | if (tlc5940 != 0) |
mjr | 55:4db125cd11a0 | 7003 | tlc5940->send(); |
mjr | 87:8d35c74403af | 7004 | |
mjr | 87:8d35c74403af | 7005 | // send TLC59116 data updates |
mjr | 87:8d35c74403af | 7006 | if (tlc59116 != 0) |
mjr | 87:8d35c74403af | 7007 | tlc59116->send(); |
mjr | 1:d913e0afb2ac | 7008 | |
mjr | 76:7f5912b6340e | 7009 | // collect diagnostic statistics, checkpoint 1 |
mjr | 76:7f5912b6340e | 7010 | IF_DIAG(mainLoopIterCheckpt[1] += mainLoopTimer.read_us();) |
mjr | 77:0b96f6867312 | 7011 | |
mjr | 1:d913e0afb2ac | 7012 | // check for plunger calibration |
mjr | 17:ab3cec0c8bf4 | 7013 | if (calBtn != 0 && !calBtn->read()) |
mjr | 0:5acbbe3f4cf4 | 7014 | { |
mjr | 1:d913e0afb2ac | 7015 | // check the state |
mjr | 1:d913e0afb2ac | 7016 | switch (calBtnState) |
mjr | 0:5acbbe3f4cf4 | 7017 | { |
mjr | 1:d913e0afb2ac | 7018 | case 0: |
mjr | 1:d913e0afb2ac | 7019 | // button not yet pushed - start debouncing |
mjr | 1:d913e0afb2ac | 7020 | calBtnTimer.reset(); |
mjr | 1:d913e0afb2ac | 7021 | calBtnState = 1; |
mjr | 1:d913e0afb2ac | 7022 | break; |
mjr | 1:d913e0afb2ac | 7023 | |
mjr | 1:d913e0afb2ac | 7024 | case 1: |
mjr | 1:d913e0afb2ac | 7025 | // pushed, not yet debounced - if the debounce time has |
mjr | 1:d913e0afb2ac | 7026 | // passed, start the hold period |
mjr | 48:058ace2aed1d | 7027 | if (calBtnTimer.read_us() > 50000) |
mjr | 1:d913e0afb2ac | 7028 | calBtnState = 2; |
mjr | 1:d913e0afb2ac | 7029 | break; |
mjr | 1:d913e0afb2ac | 7030 | |
mjr | 1:d913e0afb2ac | 7031 | case 2: |
mjr | 1:d913e0afb2ac | 7032 | // in the hold period - if the button has been held down |
mjr | 1:d913e0afb2ac | 7033 | // for the entire hold period, move to calibration mode |
mjr | 48:058ace2aed1d | 7034 | if (calBtnTimer.read_us() > 2050000) |
mjr | 1:d913e0afb2ac | 7035 | { |
mjr | 1:d913e0afb2ac | 7036 | // enter calibration mode |
mjr | 1:d913e0afb2ac | 7037 | calBtnState = 3; |
mjr | 9:fd65b0a94720 | 7038 | calBtnTimer.reset(); |
mjr | 35:e959ffba78fd | 7039 | |
mjr | 44:b5ac89b9cd5d | 7040 | // begin the plunger calibration limits |
mjr | 52:8298b2a73eb2 | 7041 | plungerReader.setCalMode(true); |
mjr | 1:d913e0afb2ac | 7042 | } |
mjr | 1:d913e0afb2ac | 7043 | break; |
mjr | 2:c174f9ee414a | 7044 | |
mjr | 2:c174f9ee414a | 7045 | case 3: |
mjr | 9:fd65b0a94720 | 7046 | // Already in calibration mode - pushing the button here |
mjr | 9:fd65b0a94720 | 7047 | // doesn't change the current state, but we won't leave this |
mjr | 9:fd65b0a94720 | 7048 | // state as long as it's held down. So nothing changes here. |
mjr | 2:c174f9ee414a | 7049 | break; |
mjr | 0:5acbbe3f4cf4 | 7050 | } |
mjr | 0:5acbbe3f4cf4 | 7051 | } |
mjr | 1:d913e0afb2ac | 7052 | else |
mjr | 1:d913e0afb2ac | 7053 | { |
mjr | 2:c174f9ee414a | 7054 | // Button released. If we're in calibration mode, and |
mjr | 2:c174f9ee414a | 7055 | // the calibration time has elapsed, end the calibration |
mjr | 2:c174f9ee414a | 7056 | // and save the results to flash. |
mjr | 2:c174f9ee414a | 7057 | // |
mjr | 2:c174f9ee414a | 7058 | // Otherwise, return to the base state without saving anything. |
mjr | 2:c174f9ee414a | 7059 | // If the button is released before we make it to calibration |
mjr | 2:c174f9ee414a | 7060 | // mode, it simply cancels the attempt. |
mjr | 48:058ace2aed1d | 7061 | if (calBtnState == 3 && calBtnTimer.read_us() > 15000000) |
mjr | 2:c174f9ee414a | 7062 | { |
mjr | 2:c174f9ee414a | 7063 | // exit calibration mode |
mjr | 1:d913e0afb2ac | 7064 | calBtnState = 0; |
mjr | 52:8298b2a73eb2 | 7065 | plungerReader.setCalMode(false); |
mjr | 2:c174f9ee414a | 7066 | |
mjr | 6:cc35eb643e8f | 7067 | // save the updated configuration |
mjr | 35:e959ffba78fd | 7068 | cfg.plunger.cal.calibrated = 1; |
mjr | 86:e30a1f60f783 | 7069 | saveConfigToFlash(0, false); |
mjr | 2:c174f9ee414a | 7070 | } |
mjr | 2:c174f9ee414a | 7071 | else if (calBtnState != 3) |
mjr | 2:c174f9ee414a | 7072 | { |
mjr | 2:c174f9ee414a | 7073 | // didn't make it to calibration mode - cancel the operation |
mjr | 1:d913e0afb2ac | 7074 | calBtnState = 0; |
mjr | 2:c174f9ee414a | 7075 | } |
mjr | 1:d913e0afb2ac | 7076 | } |
mjr | 1:d913e0afb2ac | 7077 | |
mjr | 1:d913e0afb2ac | 7078 | // light/flash the calibration button light, if applicable |
mjr | 1:d913e0afb2ac | 7079 | int newCalBtnLit = calBtnLit; |
mjr | 1:d913e0afb2ac | 7080 | switch (calBtnState) |
mjr | 0:5acbbe3f4cf4 | 7081 | { |
mjr | 1:d913e0afb2ac | 7082 | case 2: |
mjr | 1:d913e0afb2ac | 7083 | // in the hold period - flash the light |
mjr | 48:058ace2aed1d | 7084 | newCalBtnLit = ((calBtnTimer.read_us()/250000) & 1); |
mjr | 1:d913e0afb2ac | 7085 | break; |
mjr | 1:d913e0afb2ac | 7086 | |
mjr | 1:d913e0afb2ac | 7087 | case 3: |
mjr | 1:d913e0afb2ac | 7088 | // calibration mode - show steady on |
mjr | 1:d913e0afb2ac | 7089 | newCalBtnLit = true; |
mjr | 1:d913e0afb2ac | 7090 | break; |
mjr | 1:d913e0afb2ac | 7091 | |
mjr | 1:d913e0afb2ac | 7092 | default: |
mjr | 1:d913e0afb2ac | 7093 | // not calibrating/holding - show steady off |
mjr | 1:d913e0afb2ac | 7094 | newCalBtnLit = false; |
mjr | 1:d913e0afb2ac | 7095 | break; |
mjr | 1:d913e0afb2ac | 7096 | } |
mjr | 3:3514575d4f86 | 7097 | |
mjr | 3:3514575d4f86 | 7098 | // light or flash the external calibration button LED, and |
mjr | 3:3514575d4f86 | 7099 | // do the same with the on-board blue LED |
mjr | 1:d913e0afb2ac | 7100 | if (calBtnLit != newCalBtnLit) |
mjr | 1:d913e0afb2ac | 7101 | { |
mjr | 1:d913e0afb2ac | 7102 | calBtnLit = newCalBtnLit; |
mjr | 2:c174f9ee414a | 7103 | if (calBtnLit) { |
mjr | 17:ab3cec0c8bf4 | 7104 | if (calBtnLed != 0) |
mjr | 17:ab3cec0c8bf4 | 7105 | calBtnLed->write(1); |
mjr | 38:091e511ce8a0 | 7106 | diagLED(0, 0, 1); // blue |
mjr | 2:c174f9ee414a | 7107 | } |
mjr | 2:c174f9ee414a | 7108 | else { |
mjr | 17:ab3cec0c8bf4 | 7109 | if (calBtnLed != 0) |
mjr | 17:ab3cec0c8bf4 | 7110 | calBtnLed->write(0); |
mjr | 38:091e511ce8a0 | 7111 | diagLED(0, 0, 0); // off |
mjr | 2:c174f9ee414a | 7112 | } |
mjr | 1:d913e0afb2ac | 7113 | } |
mjr | 35:e959ffba78fd | 7114 | |
mjr | 76:7f5912b6340e | 7115 | // collect diagnostic statistics, checkpoint 2 |
mjr | 76:7f5912b6340e | 7116 | IF_DIAG(mainLoopIterCheckpt[2] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7117 | |
mjr | 48:058ace2aed1d | 7118 | // read the plunger sensor |
mjr | 48:058ace2aed1d | 7119 | plungerReader.read(); |
mjr | 48:058ace2aed1d | 7120 | |
mjr | 76:7f5912b6340e | 7121 | // collect diagnostic statistics, checkpoint 3 |
mjr | 76:7f5912b6340e | 7122 | IF_DIAG(mainLoopIterCheckpt[3] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7123 | |
mjr | 53:9b2611964afc | 7124 | // update the ZB Launch Ball status |
mjr | 53:9b2611964afc | 7125 | zbLaunchBall.update(); |
mjr | 37:ed52738445fc | 7126 | |
mjr | 76:7f5912b6340e | 7127 | // collect diagnostic statistics, checkpoint 4 |
mjr | 76:7f5912b6340e | 7128 | IF_DIAG(mainLoopIterCheckpt[4] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7129 | |
mjr | 53:9b2611964afc | 7130 | // process button updates |
mjr | 53:9b2611964afc | 7131 | processButtons(cfg); |
mjr | 53:9b2611964afc | 7132 | |
mjr | 76:7f5912b6340e | 7133 | // collect diagnostic statistics, checkpoint 5 |
mjr | 76:7f5912b6340e | 7134 | IF_DIAG(mainLoopIterCheckpt[5] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7135 | |
mjr | 38:091e511ce8a0 | 7136 | // send a keyboard report if we have new data |
mjr | 37:ed52738445fc | 7137 | if (kbState.changed) |
mjr | 37:ed52738445fc | 7138 | { |
mjr | 38:091e511ce8a0 | 7139 | // send a keyboard report |
mjr | 37:ed52738445fc | 7140 | js.kbUpdate(kbState.data); |
mjr | 37:ed52738445fc | 7141 | kbState.changed = false; |
mjr | 37:ed52738445fc | 7142 | } |
mjr | 38:091e511ce8a0 | 7143 | |
mjr | 38:091e511ce8a0 | 7144 | // likewise for the media controller |
mjr | 37:ed52738445fc | 7145 | if (mediaState.changed) |
mjr | 37:ed52738445fc | 7146 | { |
mjr | 38:091e511ce8a0 | 7147 | // send a media report |
mjr | 37:ed52738445fc | 7148 | js.mediaUpdate(mediaState.data); |
mjr | 37:ed52738445fc | 7149 | mediaState.changed = false; |
mjr | 37:ed52738445fc | 7150 | } |
mjr | 38:091e511ce8a0 | 7151 | |
mjr | 76:7f5912b6340e | 7152 | // collect diagnostic statistics, checkpoint 6 |
mjr | 76:7f5912b6340e | 7153 | IF_DIAG(mainLoopIterCheckpt[6] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7154 | |
mjr | 38:091e511ce8a0 | 7155 | // flag: did we successfully send a joystick report on this round? |
mjr | 38:091e511ce8a0 | 7156 | bool jsOK = false; |
mjr | 55:4db125cd11a0 | 7157 | |
mjr | 55:4db125cd11a0 | 7158 | // figure the current status flags for joystick reports |
mjr | 77:0b96f6867312 | 7159 | uint16_t statusFlags = |
mjr | 96:68d5621ff49f | 7160 | effectivePlungerEnabled // 0x01 |
mjr | 77:0b96f6867312 | 7161 | | nightMode // 0x02 |
mjr | 79:682ae3171a08 | 7162 | | ((psu2_state & 0x07) << 2) // 0x04 0x08 0x10 |
mjr | 79:682ae3171a08 | 7163 | | saveConfigSucceededFlag; // 0x40 |
mjr | 77:0b96f6867312 | 7164 | if (IRLearningMode != 0) |
mjr | 77:0b96f6867312 | 7165 | statusFlags |= 0x20; |
mjr | 17:ab3cec0c8bf4 | 7166 | |
mjr | 50:40015764bbe6 | 7167 | // If it's been long enough since our last USB status report, send |
mjr | 50:40015764bbe6 | 7168 | // the new report. VP only polls for input in 10ms intervals, so |
mjr | 50:40015764bbe6 | 7169 | // there's no benefit in sending reports more frequently than this. |
mjr | 50:40015764bbe6 | 7170 | // More frequent reporting would only add USB I/O overhead. |
mjr | 92:f264fbaa1be5 | 7171 | if (cfg.joystickEnabled && jsReportTimer.read_us() > cfg.jsReportInterval_us) |
mjr | 17:ab3cec0c8bf4 | 7172 | { |
mjr | 92:f264fbaa1be5 | 7173 | // Increment the "stutter" counter. If it has reached the |
mjr | 92:f264fbaa1be5 | 7174 | // stutter threshold, read a new accelerometer sample. If |
mjr | 92:f264fbaa1be5 | 7175 | // not, repeat the last sample. |
mjr | 92:f264fbaa1be5 | 7176 | if (++jsAccelStutterCounter >= cfg.accel.stutter) |
mjr | 92:f264fbaa1be5 | 7177 | { |
mjr | 92:f264fbaa1be5 | 7178 | // read the accelerometer |
mjr | 92:f264fbaa1be5 | 7179 | int xa, ya; |
mjr | 92:f264fbaa1be5 | 7180 | accel.get(xa, ya); |
mjr | 17:ab3cec0c8bf4 | 7181 | |
mjr | 92:f264fbaa1be5 | 7182 | // confine the results to our joystick axis range |
mjr | 92:f264fbaa1be5 | 7183 | if (xa < -JOYMAX) xa = -JOYMAX; |
mjr | 92:f264fbaa1be5 | 7184 | if (xa > JOYMAX) xa = JOYMAX; |
mjr | 92:f264fbaa1be5 | 7185 | if (ya < -JOYMAX) ya = -JOYMAX; |
mjr | 92:f264fbaa1be5 | 7186 | if (ya > JOYMAX) ya = JOYMAX; |
mjr | 92:f264fbaa1be5 | 7187 | |
mjr | 92:f264fbaa1be5 | 7188 | // store the updated accelerometer coordinates |
mjr | 92:f264fbaa1be5 | 7189 | x = xa; |
mjr | 92:f264fbaa1be5 | 7190 | y = ya; |
mjr | 92:f264fbaa1be5 | 7191 | |
mjr | 95:8eca8acbb82c | 7192 | // rotate X and Y according to the device orientation in the cabinet |
mjr | 95:8eca8acbb82c | 7193 | accelRotate(x, y); |
mjr | 95:8eca8acbb82c | 7194 | |
mjr | 92:f264fbaa1be5 | 7195 | // reset the stutter counter |
mjr | 92:f264fbaa1be5 | 7196 | jsAccelStutterCounter = 0; |
mjr | 92:f264fbaa1be5 | 7197 | } |
mjr | 17:ab3cec0c8bf4 | 7198 | |
mjr | 48:058ace2aed1d | 7199 | // Report the current plunger position unless the plunger is |
mjr | 48:058ace2aed1d | 7200 | // disabled, or the ZB Launch Ball signal is on. In either of |
mjr | 48:058ace2aed1d | 7201 | // those cases, just report a constant 0 value. ZB Launch Ball |
mjr | 48:058ace2aed1d | 7202 | // temporarily disables mechanical plunger reporting because it |
mjr | 21:5048e16cc9ef | 7203 | // tells us that the table has a Launch Ball button instead of |
mjr | 48:058ace2aed1d | 7204 | // a traditional plunger, so we don't want to confuse VP with |
mjr | 48:058ace2aed1d | 7205 | // regular plunger inputs. |
mjr | 92:f264fbaa1be5 | 7206 | int zActual = plungerReader.getPosition(); |
mjr | 96:68d5621ff49f | 7207 | int zReported = (!effectivePlungerEnabled || zbLaunchOn ? 0 : zActual); |
mjr | 35:e959ffba78fd | 7208 | |
mjr | 35:e959ffba78fd | 7209 | // send the joystick report |
mjr | 92:f264fbaa1be5 | 7210 | jsOK = js.update(x, y, zReported, jsButtons, statusFlags); |
mjr | 21:5048e16cc9ef | 7211 | |
mjr | 17:ab3cec0c8bf4 | 7212 | // we've just started a new report interval, so reset the timer |
mjr | 38:091e511ce8a0 | 7213 | jsReportTimer.reset(); |
mjr | 17:ab3cec0c8bf4 | 7214 | } |
mjr | 21:5048e16cc9ef | 7215 | |
mjr | 52:8298b2a73eb2 | 7216 | // If we're in sensor status mode, report all pixel exposure values |
mjr | 101:755f44622abc | 7217 | if (reportPlungerStat && plungerSensor->ready()) |
mjr | 10:976666ffa4ef | 7218 | { |
mjr | 17:ab3cec0c8bf4 | 7219 | // send the report |
mjr | 101:755f44622abc | 7220 | plungerSensor->sendStatusReport(js, reportPlungerStatFlags); |
mjr | 17:ab3cec0c8bf4 | 7221 | |
mjr | 10:976666ffa4ef | 7222 | // we have satisfied this request |
mjr | 52:8298b2a73eb2 | 7223 | reportPlungerStat = false; |
mjr | 10:976666ffa4ef | 7224 | } |
mjr | 10:976666ffa4ef | 7225 | |
mjr | 101:755f44622abc | 7226 | // Reset the plunger status report extra timer after enough time has |
mjr | 101:755f44622abc | 7227 | // elapsed to satisfy the request. We don't just do this immediately |
mjr | 101:755f44622abc | 7228 | // because of the complexities of the pixel frame buffer pipelines in |
mjr | 101:755f44622abc | 7229 | // most of the image sensors. The pipelines delay the effect of the |
mjr | 101:755f44622abc | 7230 | // exposure time request by a couple of frames, so we can't be sure |
mjr | 101:755f44622abc | 7231 | // exactly when they're applied - meaning we can't consider the |
mjr | 101:755f44622abc | 7232 | // delay time to be consumed after a fixed number of frames. Instead, |
mjr | 101:755f44622abc | 7233 | // we'll consider it consumed after a long enough time to be sure |
mjr | 101:755f44622abc | 7234 | // we've sent a few frames. The extra time value is meant to be an |
mjr | 101:755f44622abc | 7235 | // interactive tool for debugging, so it's not important to reset it |
mjr | 101:755f44622abc | 7236 | // immediately - the user will probably want to see the effect over |
mjr | 101:755f44622abc | 7237 | // many frames, so they're likely to keep sending requests with the |
mjr | 101:755f44622abc | 7238 | // time value over and over. They'll eventually shut down the frame |
mjr | 101:755f44622abc | 7239 | // viewer and return to normal operation, at which point the requests |
mjr | 101:755f44622abc | 7240 | // will stop. So we just have to clear things out after we haven't |
mjr | 101:755f44622abc | 7241 | // seen a request with extra time for a little while. |
mjr | 101:755f44622abc | 7242 | if (reportPlungerStatTime != 0 |
mjr | 101:755f44622abc | 7243 | && static_cast<uint32_t>(requestTimestamper.read_us() - tReportPlungerStat) > 1000000) |
mjr | 101:755f44622abc | 7244 | { |
mjr | 101:755f44622abc | 7245 | reportPlungerStatTime = 0; |
mjr | 101:755f44622abc | 7246 | plungerSensor->setExtraIntegrationTime(0); |
mjr | 101:755f44622abc | 7247 | } |
mjr | 101:755f44622abc | 7248 | |
mjr | 35:e959ffba78fd | 7249 | // If joystick reports are turned off, send a generic status report |
mjr | 35:e959ffba78fd | 7250 | // periodically for the sake of the Windows config tool. |
mjr | 77:0b96f6867312 | 7251 | if (!cfg.joystickEnabled && jsReportTimer.read_us() > 10000UL) |
mjr | 21:5048e16cc9ef | 7252 | { |
mjr | 55:4db125cd11a0 | 7253 | jsOK = js.updateStatus(statusFlags); |
mjr | 38:091e511ce8a0 | 7254 | jsReportTimer.reset(); |
mjr | 38:091e511ce8a0 | 7255 | } |
mjr | 38:091e511ce8a0 | 7256 | |
mjr | 38:091e511ce8a0 | 7257 | // if we successfully sent a joystick report, reset the watchdog timer |
mjr | 38:091e511ce8a0 | 7258 | if (jsOK) |
mjr | 38:091e511ce8a0 | 7259 | { |
mjr | 38:091e511ce8a0 | 7260 | jsOKTimer.reset(); |
mjr | 38:091e511ce8a0 | 7261 | jsOKTimer.start(); |
mjr | 21:5048e16cc9ef | 7262 | } |
mjr | 21:5048e16cc9ef | 7263 | |
mjr | 76:7f5912b6340e | 7264 | // collect diagnostic statistics, checkpoint 7 |
mjr | 76:7f5912b6340e | 7265 | IF_DIAG(mainLoopIterCheckpt[7] += mainLoopTimer.read_us();) |
mjr | 76:7f5912b6340e | 7266 | |
mjr | 6:cc35eb643e8f | 7267 | #ifdef DEBUG_PRINTF |
mjr | 6:cc35eb643e8f | 7268 | if (x != 0 || y != 0) |
mjr | 6:cc35eb643e8f | 7269 | printf("%d,%d\r\n", x, y); |
mjr | 6:cc35eb643e8f | 7270 | #endif |
mjr | 6:cc35eb643e8f | 7271 | |
mjr | 33:d832bcab089e | 7272 | // check for connection status changes |
mjr | 54:fd77a6b2f76c | 7273 | bool newConnected = js.isConnected() && !js.isSleeping(); |
mjr | 33:d832bcab089e | 7274 | if (newConnected != connected) |
mjr | 33:d832bcab089e | 7275 | { |
mjr | 54:fd77a6b2f76c | 7276 | // give it a moment to stabilize |
mjr | 40:cc0d9814522b | 7277 | connectChangeTimer.start(); |
mjr | 55:4db125cd11a0 | 7278 | if (connectChangeTimer.read_us() > 1000000) |
mjr | 33:d832bcab089e | 7279 | { |
mjr | 33:d832bcab089e | 7280 | // note the new status |
mjr | 33:d832bcab089e | 7281 | connected = newConnected; |
mjr | 40:cc0d9814522b | 7282 | |
mjr | 40:cc0d9814522b | 7283 | // done with the change timer for this round - reset it for next time |
mjr | 40:cc0d9814522b | 7284 | connectChangeTimer.stop(); |
mjr | 40:cc0d9814522b | 7285 | connectChangeTimer.reset(); |
mjr | 33:d832bcab089e | 7286 | |
mjr | 54:fd77a6b2f76c | 7287 | // if we're newly disconnected, clean up for PC suspend mode or power off |
mjr | 54:fd77a6b2f76c | 7288 | if (!connected) |
mjr | 40:cc0d9814522b | 7289 | { |
mjr | 54:fd77a6b2f76c | 7290 | // turn off all outputs |
mjr | 33:d832bcab089e | 7291 | allOutputsOff(); |
mjr | 40:cc0d9814522b | 7292 | |
mjr | 40:cc0d9814522b | 7293 | // The KL25Z runs off of USB power, so we might (depending on the PC |
mjr | 40:cc0d9814522b | 7294 | // and OS configuration) continue to receive power even when the main |
mjr | 40:cc0d9814522b | 7295 | // PC power supply is turned off, such as in soft-off or suspend/sleep |
mjr | 40:cc0d9814522b | 7296 | // mode. Any external output controller chips (TLC5940, 74HC595) might |
mjr | 40:cc0d9814522b | 7297 | // be powered from the PC power supply directly rather than from our |
mjr | 40:cc0d9814522b | 7298 | // USB power, so they might be powered off even when we're still running. |
mjr | 40:cc0d9814522b | 7299 | // To ensure cleaner startup when the power comes back on, globally |
mjr | 40:cc0d9814522b | 7300 | // disable the outputs. The global disable signals come from GPIO lines |
mjr | 40:cc0d9814522b | 7301 | // that remain powered as long as the KL25Z is powered, so these modes |
mjr | 40:cc0d9814522b | 7302 | // will apply smoothly across power state transitions in the external |
mjr | 40:cc0d9814522b | 7303 | // hardware. That is, when the external chips are powered up, they'll |
mjr | 40:cc0d9814522b | 7304 | // see the global disable signals as stable voltage inputs immediately, |
mjr | 40:cc0d9814522b | 7305 | // which will cause them to suppress any output triggering. This ensures |
mjr | 40:cc0d9814522b | 7306 | // that we don't fire any solenoids or flash any lights spuriously when |
mjr | 40:cc0d9814522b | 7307 | // the power first comes on. |
mjr | 40:cc0d9814522b | 7308 | if (tlc5940 != 0) |
mjr | 40:cc0d9814522b | 7309 | tlc5940->enable(false); |
mjr | 87:8d35c74403af | 7310 | if (tlc59116 != 0) |
mjr | 87:8d35c74403af | 7311 | tlc59116->enable(false); |
mjr | 40:cc0d9814522b | 7312 | if (hc595 != 0) |
mjr | 40:cc0d9814522b | 7313 | hc595->enable(false); |
mjr | 40:cc0d9814522b | 7314 | } |
mjr | 33:d832bcab089e | 7315 | } |
mjr | 33:d832bcab089e | 7316 | } |
mjr | 48:058ace2aed1d | 7317 | |
mjr | 53:9b2611964afc | 7318 | // if we have a reboot timer pending, check for completion |
mjr | 86:e30a1f60f783 | 7319 | if (saveConfigFollowupTimer.isRunning() |
mjr | 87:8d35c74403af | 7320 | && saveConfigFollowupTimer.read_us() > saveConfigFollowupTime*1000000UL) |
mjr | 85:3c28aee81cde | 7321 | { |
mjr | 85:3c28aee81cde | 7322 | // if a reboot is pending, execute it now |
mjr | 86:e30a1f60f783 | 7323 | if (saveConfigRebootPending) |
mjr | 82:4f6209cb5c33 | 7324 | { |
mjr | 86:e30a1f60f783 | 7325 | // Only reboot if the PSU2 power state allows it. If it |
mjr | 86:e30a1f60f783 | 7326 | // doesn't, suppress the reboot for now, but leave the boot |
mjr | 86:e30a1f60f783 | 7327 | // flags set so that we keep checking on future rounds. |
mjr | 86:e30a1f60f783 | 7328 | // That way we should eventually reboot when the power |
mjr | 86:e30a1f60f783 | 7329 | // status allows it. |
mjr | 86:e30a1f60f783 | 7330 | if (powerStatusAllowsReboot()) |
mjr | 86:e30a1f60f783 | 7331 | reboot(js); |
mjr | 82:4f6209cb5c33 | 7332 | } |
mjr | 85:3c28aee81cde | 7333 | else |
mjr | 85:3c28aee81cde | 7334 | { |
mjr | 86:e30a1f60f783 | 7335 | // No reboot required. Exit the timed post-save state. |
mjr | 86:e30a1f60f783 | 7336 | |
mjr | 86:e30a1f60f783 | 7337 | // stop and reset the post-save timer |
mjr | 86:e30a1f60f783 | 7338 | saveConfigFollowupTimer.stop(); |
mjr | 86:e30a1f60f783 | 7339 | saveConfigFollowupTimer.reset(); |
mjr | 86:e30a1f60f783 | 7340 | |
mjr | 86:e30a1f60f783 | 7341 | // clear the post-save success flag |
mjr | 86:e30a1f60f783 | 7342 | saveConfigSucceededFlag = 0; |
mjr | 85:3c28aee81cde | 7343 | } |
mjr | 77:0b96f6867312 | 7344 | } |
mjr | 86:e30a1f60f783 | 7345 | |
mjr | 48:058ace2aed1d | 7346 | // if we're disconnected, initiate a new connection |
mjr | 51:57eb311faafa | 7347 | if (!connected) |
mjr | 48:058ace2aed1d | 7348 | { |
mjr | 54:fd77a6b2f76c | 7349 | // show USB HAL debug events |
mjr | 54:fd77a6b2f76c | 7350 | extern void HAL_DEBUG_PRINTEVENTS(const char *prefix); |
mjr | 54:fd77a6b2f76c | 7351 | HAL_DEBUG_PRINTEVENTS(">DISC"); |
mjr | 54:fd77a6b2f76c | 7352 | |
mjr | 54:fd77a6b2f76c | 7353 | // show immediate diagnostic feedback |
mjr | 54:fd77a6b2f76c | 7354 | js.diagFlash(); |
mjr | 54:fd77a6b2f76c | 7355 | |
mjr | 54:fd77a6b2f76c | 7356 | // clear any previous diagnostic LED display |
mjr | 54:fd77a6b2f76c | 7357 | diagLED(0, 0, 0); |
mjr | 51:57eb311faafa | 7358 | |
mjr | 51:57eb311faafa | 7359 | // set up a timer to monitor the reboot timeout |
mjr | 70:9f58735a1732 | 7360 | Timer reconnTimeoutTimer; |
mjr | 70:9f58735a1732 | 7361 | reconnTimeoutTimer.start(); |
mjr | 48:058ace2aed1d | 7362 | |
mjr | 54:fd77a6b2f76c | 7363 | // set up a timer for diagnostic displays |
mjr | 54:fd77a6b2f76c | 7364 | Timer diagTimer; |
mjr | 54:fd77a6b2f76c | 7365 | diagTimer.reset(); |
mjr | 54:fd77a6b2f76c | 7366 | diagTimer.start(); |
mjr | 74:822a92bc11d2 | 7367 | |
mjr | 74:822a92bc11d2 | 7368 | // turn off the main loop timer while spinning |
mjr | 74:822a92bc11d2 | 7369 | IF_DIAG(mainLoopTimer.stop();) |
mjr | 54:fd77a6b2f76c | 7370 | |
mjr | 54:fd77a6b2f76c | 7371 | // loop until we get our connection back |
mjr | 54:fd77a6b2f76c | 7372 | while (!js.isConnected() || js.isSleeping()) |
mjr | 51:57eb311faafa | 7373 | { |
mjr | 54:fd77a6b2f76c | 7374 | // try to recover the connection |
mjr | 54:fd77a6b2f76c | 7375 | js.recoverConnection(); |
mjr | 54:fd77a6b2f76c | 7376 | |
mjr | 99:8139b0c274f4 | 7377 | // update Flipper Logic and Chime Logic outputs |
mjr | 89:c43cd923401c | 7378 | LwFlipperLogicOut::poll(); |
mjr | 99:8139b0c274f4 | 7379 | LwChimeLogicOut::poll(); |
mjr | 89:c43cd923401c | 7380 | |
mjr | 55:4db125cd11a0 | 7381 | // send TLC5940 data if necessary |
mjr | 55:4db125cd11a0 | 7382 | if (tlc5940 != 0) |
mjr | 55:4db125cd11a0 | 7383 | tlc5940->send(); |
mjr | 87:8d35c74403af | 7384 | |
mjr | 87:8d35c74403af | 7385 | // update TLC59116 outputs |
mjr | 87:8d35c74403af | 7386 | if (tlc59116 != 0) |
mjr | 87:8d35c74403af | 7387 | tlc59116->send(); |
mjr | 55:4db125cd11a0 | 7388 | |
mjr | 54:fd77a6b2f76c | 7389 | // show a diagnostic flash every couple of seconds |
mjr | 54:fd77a6b2f76c | 7390 | if (diagTimer.read_us() > 2000000) |
mjr | 51:57eb311faafa | 7391 | { |
mjr | 54:fd77a6b2f76c | 7392 | // flush the USB HAL debug events, if in debug mode |
mjr | 54:fd77a6b2f76c | 7393 | HAL_DEBUG_PRINTEVENTS(">NC"); |
mjr | 54:fd77a6b2f76c | 7394 | |
mjr | 54:fd77a6b2f76c | 7395 | // show diagnostic feedback |
mjr | 54:fd77a6b2f76c | 7396 | js.diagFlash(); |
mjr | 51:57eb311faafa | 7397 | |
mjr | 51:57eb311faafa | 7398 | // reset the flash timer |
mjr | 54:fd77a6b2f76c | 7399 | diagTimer.reset(); |
mjr | 51:57eb311faafa | 7400 | } |
mjr | 51:57eb311faafa | 7401 | |
mjr | 77:0b96f6867312 | 7402 | // If the disconnect reboot timeout has expired, reboot. |
mjr | 77:0b96f6867312 | 7403 | // Some PC hosts won't reconnect to a device that's left |
mjr | 77:0b96f6867312 | 7404 | // plugged in through various events on the PC side, such as |
mjr | 77:0b96f6867312 | 7405 | // rebooting Windows, cycling power on the PC, or just a lost |
mjr | 77:0b96f6867312 | 7406 | // USB connection. Rebooting the KL25Z seems to be the most |
mjr | 77:0b96f6867312 | 7407 | // reliable way to get Windows to notice us again after one |
mjr | 86:e30a1f60f783 | 7408 | // of these events and make it reconnect. Only reboot if |
mjr | 86:e30a1f60f783 | 7409 | // the PSU2 power status allows it - if not, skip it on this |
mjr | 86:e30a1f60f783 | 7410 | // round and keep waiting. |
mjr | 51:57eb311faafa | 7411 | if (cfg.disconnectRebootTimeout != 0 |
mjr | 86:e30a1f60f783 | 7412 | && reconnTimeoutTimer.read() > cfg.disconnectRebootTimeout |
mjr | 86:e30a1f60f783 | 7413 | && powerStatusAllowsReboot()) |
mjr | 54:fd77a6b2f76c | 7414 | reboot(js, false, 0); |
mjr | 77:0b96f6867312 | 7415 | |
mjr | 77:0b96f6867312 | 7416 | // update the PSU2 power sensing status |
mjr | 77:0b96f6867312 | 7417 | powerStatusUpdate(cfg); |
mjr | 54:fd77a6b2f76c | 7418 | } |
mjr | 54:fd77a6b2f76c | 7419 | |
mjr | 74:822a92bc11d2 | 7420 | // resume the main loop timer |
mjr | 74:822a92bc11d2 | 7421 | IF_DIAG(mainLoopTimer.start();) |
mjr | 74:822a92bc11d2 | 7422 | |
mjr | 54:fd77a6b2f76c | 7423 | // if we made it out of that loop alive, we're connected again! |
mjr | 54:fd77a6b2f76c | 7424 | connected = true; |
mjr | 54:fd77a6b2f76c | 7425 | HAL_DEBUG_PRINTEVENTS(">C"); |
mjr | 54:fd77a6b2f76c | 7426 | |
mjr | 54:fd77a6b2f76c | 7427 | // Enable peripheral chips and update them with current output data |
mjr | 54:fd77a6b2f76c | 7428 | if (tlc5940 != 0) |
mjr | 55:4db125cd11a0 | 7429 | tlc5940->enable(true); |
mjr | 87:8d35c74403af | 7430 | if (tlc59116 != 0) |
mjr | 87:8d35c74403af | 7431 | tlc59116->enable(true); |
mjr | 54:fd77a6b2f76c | 7432 | if (hc595 != 0) |
mjr | 54:fd77a6b2f76c | 7433 | { |
mjr | 55:4db125cd11a0 | 7434 | hc595->enable(true); |
mjr | 54:fd77a6b2f76c | 7435 | hc595->update(true); |
mjr | 51:57eb311faafa | 7436 | } |
mjr | 48:058ace2aed1d | 7437 | } |
mjr | 43:7a6364d82a41 | 7438 | |
mjr | 6:cc35eb643e8f | 7439 | // provide a visual status indication on the on-board LED |
mjr | 48:058ace2aed1d | 7440 | if (calBtnState < 2 && hbTimer.read_us() > 1000000) |
mjr | 1:d913e0afb2ac | 7441 | { |
mjr | 54:fd77a6b2f76c | 7442 | if (jsOKTimer.read_us() > 1000000) |
mjr | 38:091e511ce8a0 | 7443 | { |
mjr | 39:b3815a1c3802 | 7444 | // USB freeze - show red/yellow. |
mjr | 40:cc0d9814522b | 7445 | // |
mjr | 54:fd77a6b2f76c | 7446 | // It's been more than a second since we successfully sent a joystick |
mjr | 54:fd77a6b2f76c | 7447 | // update message. This must mean that something's wrong on the USB |
mjr | 54:fd77a6b2f76c | 7448 | // connection, even though we haven't detected an outright disconnect. |
mjr | 54:fd77a6b2f76c | 7449 | // Show a distinctive diagnostic LED pattern when this occurs. |
mjr | 38:091e511ce8a0 | 7450 | hb = !hb; |
mjr | 38:091e511ce8a0 | 7451 | diagLED(1, hb, 0); |
mjr | 54:fd77a6b2f76c | 7452 | |
mjr | 54:fd77a6b2f76c | 7453 | // If the reboot-on-disconnect option is in effect, treat this condition |
mjr | 54:fd77a6b2f76c | 7454 | // as equivalent to a disconnect, since something is obviously wrong |
mjr | 54:fd77a6b2f76c | 7455 | // with the USB connection. |
mjr | 54:fd77a6b2f76c | 7456 | if (cfg.disconnectRebootTimeout != 0) |
mjr | 54:fd77a6b2f76c | 7457 | { |
mjr | 54:fd77a6b2f76c | 7458 | // The reboot timeout is in effect. If we've been incommunicado for |
mjr | 54:fd77a6b2f76c | 7459 | // longer than the timeout, reboot. If we haven't reached the time |
mjr | 54:fd77a6b2f76c | 7460 | // limit, keep running for now, and leave the OK timer running so |
mjr | 86:e30a1f60f783 | 7461 | // that we can continue to monitor this. Only reboot if the PSU2 |
mjr | 86:e30a1f60f783 | 7462 | // power status allows it. |
mjr | 86:e30a1f60f783 | 7463 | if (jsOKTimer.read() > cfg.disconnectRebootTimeout |
mjr | 86:e30a1f60f783 | 7464 | && powerStatusAllowsReboot()) |
mjr | 54:fd77a6b2f76c | 7465 | reboot(js, false, 0); |
mjr | 54:fd77a6b2f76c | 7466 | } |
mjr | 54:fd77a6b2f76c | 7467 | else |
mjr | 54:fd77a6b2f76c | 7468 | { |
mjr | 54:fd77a6b2f76c | 7469 | // There's no reboot timer, so just keep running with the diagnostic |
mjr | 54:fd77a6b2f76c | 7470 | // pattern displayed. Since we're not waiting for any other timed |
mjr | 54:fd77a6b2f76c | 7471 | // conditions in this state, stop the timer so that it doesn't |
mjr | 54:fd77a6b2f76c | 7472 | // overflow if this condition persists for a long time. |
mjr | 54:fd77a6b2f76c | 7473 | jsOKTimer.stop(); |
mjr | 54:fd77a6b2f76c | 7474 | } |
mjr | 38:091e511ce8a0 | 7475 | } |
mjr | 73:4e8ce0b18915 | 7476 | else if (psu2_state >= 4) |
mjr | 73:4e8ce0b18915 | 7477 | { |
mjr | 73:4e8ce0b18915 | 7478 | // We're in the TV timer countdown. Skip the normal heartbeat |
mjr | 73:4e8ce0b18915 | 7479 | // flashes and show the TV timer flashes instead. |
mjr | 73:4e8ce0b18915 | 7480 | diagLED(0, 0, 0); |
mjr | 73:4e8ce0b18915 | 7481 | } |
mjr | 96:68d5621ff49f | 7482 | else if (effectivePlungerEnabled && !cfg.plunger.cal.calibrated) |
mjr | 6:cc35eb643e8f | 7483 | { |
mjr | 6:cc35eb643e8f | 7484 | // connected, plunger calibration needed - flash yellow/green |
mjr | 6:cc35eb643e8f | 7485 | hb = !hb; |
mjr | 38:091e511ce8a0 | 7486 | diagLED(hb, 1, 0); |
mjr | 6:cc35eb643e8f | 7487 | } |
mjr | 6:cc35eb643e8f | 7488 | else |
mjr | 6:cc35eb643e8f | 7489 | { |
mjr | 6:cc35eb643e8f | 7490 | // connected - flash blue/green |
mjr | 2:c174f9ee414a | 7491 | hb = !hb; |
mjr | 38:091e511ce8a0 | 7492 | diagLED(0, hb, !hb); |
mjr | 2:c174f9ee414a | 7493 | } |
mjr | 1:d913e0afb2ac | 7494 | |
mjr | 1:d913e0afb2ac | 7495 | // reset the heartbeat timer |
mjr | 1:d913e0afb2ac | 7496 | hbTimer.reset(); |
mjr | 5:a70c0bce770d | 7497 | ++hbcnt; |
mjr | 1:d913e0afb2ac | 7498 | } |
mjr | 74:822a92bc11d2 | 7499 | |
mjr | 74:822a92bc11d2 | 7500 | // collect statistics on the main loop time, if desired |
mjr | 74:822a92bc11d2 | 7501 | IF_DIAG( |
mjr | 76:7f5912b6340e | 7502 | mainLoopIterTime += mainLoopTimer.read_us(); |
mjr | 74:822a92bc11d2 | 7503 | mainLoopIterCount++; |
mjr | 74:822a92bc11d2 | 7504 | ) |
mjr | 1:d913e0afb2ac | 7505 | } |
mjr | 0:5acbbe3f4cf4 | 7506 | } |