Pinscape_Controller - work in progress

Users » mkalkbrenner » Code » Pinscape_Controller

Markus Kalkbrenner / Mbed 2 deprecated Pinscape_Controller

work in progress

Dependencies: FastAnalogIn FastIO USBDevice mbed FastPWM SimpleDMA

Fork of Pinscape_Controller by Mike R

main.cpp@10:976666ffa4ef, 2014-08-23 (annotated)

Committer:: mjr
Date:: Sat Aug 23 01:24:36 2014 +0000
Revision:: 10:976666ffa4ef
Parent:: 9:fd65b0a94720
Child:: 11:bd9da7088e6e

Add raw pixel dump support for use by the Windows config tool

Who changed what in which revision?

User	Revision	Line number	New contents of line
mjr	5:a70c0bce770d	1	/* Copyright 2014 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	5:a70c0bce770d	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	5:a70c0bce770d	20	// Pinscape Controller
mjr	5:a70c0bce770d	21	//
mjr	5:a70c0bce770d	22	// "Pinscape" is the name of my custom-built virtual pinball cabinet. I wrote this
mjr	5:a70c0bce770d	23	// software to perform a number of tasks that I needed for my cabinet. It runs on a
mjr	5:a70c0bce770d	24	// Freescale KL25Z microcontroller, which is a small and inexpensive device that
mjr	5:a70c0bce770d	25	// attaches to the host PC via USB and can interface with numerous types of external
mjr	5:a70c0bce770d	26	// hardware.
mjr	5:a70c0bce770d	27	//
mjr	5:a70c0bce770d	28	// I designed the software and hardware in this project especially for Pinscape, but
mjr	5:a70c0bce770d	29	// it uses standard interfaces in Windows and Visual Pinball, so it should be
mjr	5:a70c0bce770d	30	// readily usable in anyone else's VP-based cabinet. I've tried to document the
mjr	5:a70c0bce770d	31	// hardware in enough detail for anyone else to duplicate the entire project, and
mjr	5:a70c0bce770d	32	// the full software is open source.
mjr	5:a70c0bce770d	33	//
mjr	6:cc35eb643e8f	34	// The device appears to the host computer as a USB joystick. This works with the
mjr	6:cc35eb643e8f	35	// standard Windows joystick device drivers, so there's no need to install any
mjr	6:cc35eb643e8f	36	// software on the PC - Windows should recognize it as a joystick when you plug
mjr	6:cc35eb643e8f	37	// it in and shouldn't ask you to install anything. If you bring up the control
mjr	6:cc35eb643e8f	38	// panel for USB Game Controllers, this device will appear as "Pinscape Controller".
mjr	6:cc35eb643e8f	39	// Don't do any calibration with the Windows control panel or third-part
mjr	6:cc35eb643e8f	40	// calibration tools. The device calibrates itself automatically for the
mjr	6:cc35eb643e8f	41	// accelerometer data, and has its own special calibration procedure for the
mjr	6:cc35eb643e8f	42	// plunger (see below).
mjr	6:cc35eb643e8f	43	//
mjr	5:a70c0bce770d	44	// The controller provides the following functions. It should be possible to use
mjr	5:a70c0bce770d	45	// any subet of the features without using all of them. External hardware for any
mjr	5:a70c0bce770d	46	// particular function can simply be omitted if that feature isn't needed.
mjr	5:a70c0bce770d	47	//
mjr	5:a70c0bce770d	48	// - Nudge sensing via the KL25Z's on-board accelerometer. Nudge accelerations are
mjr	5:a70c0bce770d	49	// processed into a physics model of a rolling ball, and changes to the ball's
mjr	5:a70c0bce770d	50	// motion are sent to the host computer via the joystick interface. This is designed
mjr	5:a70c0bce770d	51	// especially to work with Visuall Pinball's nudge handling to produce realistic
mjr	5:a70c0bce770d	52	// on-screen results in VP. By doing some physics modeling right on the device,
mjr	5:a70c0bce770d	53	// rather than sending raw accelerometer data to VP, we can produce better results
mjr	5:a70c0bce770d	54	// using our awareness of the real physical parameters of a pinball cabinet.
mjr	5:a70c0bce770d	55	// VP's nudge handling has to be more generic, so it can't make the same sorts
mjr	5:a70c0bce770d	56	// of assumptions that we can about the dynamics of a real cabinet.
mjr	5:a70c0bce770d	57	//
mjr	5:a70c0bce770d	58	// The nudge data reports are compatible with the built-in Windows USB joystick
mjr	5:a70c0bce770d	59	// drivers and with VP's own joystick input scheme, so the nudge sensing is almost
mjr	5:a70c0bce770d	60	// plug-and-play. There are no Windiows drivers to install, and the only VP work
mjr	5:a70c0bce770d	61	// needed is to customize a few global preference settings.
mjr	5:a70c0bce770d	62	//
mjr	5:a70c0bce770d	63	// - Plunger position sensing via an attached TAOS TSL 1410R CCD linear array sensor.
mjr	5:a70c0bce770d	64	// The sensor must be wired to a particular set of I/O ports on the KL25Z, and must
mjr	5:a70c0bce770d	65	// be positioned adjacent to the plunger with proper lighting. The physical and
mjr	5:a70c0bce770d	66	// electronic installation details are desribed in the project documentation. We read
mjr	5:a70c0bce770d	67	// the CCD to determine how far back the plunger is pulled, and report this to Visual
mjr	5:a70c0bce770d	68	// Pinball via the joystick interface. As with the nudge data, this is all nearly
mjr	5:a70c0bce770d	69	// plug-and-play, in that it works with the default Windows USB drivers and works
mjr	5:a70c0bce770d	70	// with the existing VP handling for analog plunger input. A few VP settings are
mjr	5:a70c0bce770d	71	// needed to tell VP to allow the plunger.
mjr	5:a70c0bce770d	72	//
mjr	6:cc35eb643e8f	73	// For best results, the plunger sensor should be calibrated. The calibration
mjr	6:cc35eb643e8f	74	// is stored in non-volatile memory on board the KL25Z, so it's only necessary
mjr	6:cc35eb643e8f	75	// to do the calibration once, when you first install everything. (You might
mjr	6:cc35eb643e8f	76	// also want to re-calibrate if you physically remove and reinstall the CCD
mjr	6:cc35eb643e8f	77	// sensor or the mechanical plunger, since their alignment might change slightly
mjr	6:cc35eb643e8f	78	// when you put everything back together.) To calibrate, you have to attach a
mjr	6:cc35eb643e8f	79	// momentary switch (e.g., a push-button switch) between one of the KL25Z ground
mjr	6:cc35eb643e8f	80	// pins (e.g., jumper J9 pin 12) and PTE29 (J10 pin 9). Press and hold the
mjr	6:cc35eb643e8f	81	// button for about two seconds - the LED on the KL25Z wlil flash blue while
mjr	6:cc35eb643e8f	82	// you hold the button, and will turn solid blue when you've held it down long
mjr	6:cc35eb643e8f	83	// enough to enter calibration mode. This mode will last about 15 seconds.
mjr	6:cc35eb643e8f	84	// Simply pull the plunger all the way back, hold it for a few moments, and
mjr	6:cc35eb643e8f	85	// gradually return it to the starting position. Don't release it - we want
mjr	6:cc35eb643e8f	86	// to measure the maximum retracted position and the rest position, but NOT
mjr	6:cc35eb643e8f	87	// the maximum forward position when the outer barrel spring is compressed.
mjr	6:cc35eb643e8f	88	// After about 15 seconds, the device will save the new calibration settings
mjr	6:cc35eb643e8f	89	// to its flash memory, and the LED will return to the regular "heartbeat"
mjr	6:cc35eb643e8f	90	// flashes. If this is the first time you calibrated, you should observe the
mjr	6:cc35eb643e8f	91	// color of the flashes change from yellow/green to blue/green to indicate
mjr	6:cc35eb643e8f	92	// that the plunger has been calibrated.
mjr	6:cc35eb643e8f	93	//
mjr	6:cc35eb643e8f	94	// Note that while Visual Pinball itself has good native support for analog
mjr	6:cc35eb643e8f	95	// plungers, most of the VP tables in circulation don't implement the necessary
mjr	6:cc35eb643e8f	96	// scripting features to make this work properly. Therefore, you'll have to do
mjr	6:cc35eb643e8f	97	// a little scripting work for each table you download to add the required code
mjr	6:cc35eb643e8f	98	// to that individual table. The work has to be customized for each table, so
mjr	6:cc35eb643e8f	99	// I haven't been able to automate this process, but I have tried to reduce it
mjr	6:cc35eb643e8f	100	// to a relatively simple recipe that I've documented separately.
mjr	5:a70c0bce770d	101	//
mjr	5:a70c0bce770d	102	// - In addition to the CCD sensor, a button should be attached (also described in
mjr	5:a70c0bce770d	103	// the project documentation) to activate calibration mode for the plunger. When
mjr	5:a70c0bce770d	104	// calibration mode is activated, the software reads the plunger position for about
mjr	5:a70c0bce770d	105	// 10 seconds when to note the limits of travel, and uses these limits to ensure
mjr	5:a70c0bce770d	106	// accurate reports to VP that properly report the actual position of the physical
mjr	5:a70c0bce770d	107	// plunger. The calibration is stored in non-volatile memory on the KL25Z, so it's
mjr	5:a70c0bce770d	108	// only necessary to calibrate once - the calibration will survive power cycling
mjr	5:a70c0bce770d	109	// and reboots of the PC. It's only necessary to recalibrate if the CCD sensor or
mjr	5:a70c0bce770d	110	// the plunger are removed and reinstalled, since the relative alignment of the
mjr	5:a70c0bce770d	111	// parts could cahnge slightly when reinstalling.
mjr	5:a70c0bce770d	112	//
mjr	5:a70c0bce770d	113	// - LedWiz emulation. The KL25Z can appear to the PC as an LedWiz device, and will
mjr	5:a70c0bce770d	114	// accept and process LedWiz commands from the host. The software can turn digital
mjr	5:a70c0bce770d	115	// output ports on and off, and can set varying PWM intensitiy levels on a subset
mjr	5:a70c0bce770d	116	// of ports. (The KL25Z can only provide 6 PWM ports. Intensity level settings on
mjr	5:a70c0bce770d	117	// other ports is ignored, so non-PWM ports can only be used for simple on/off
mjr	5:a70c0bce770d	118	// devices such as contactors and solenoids.) The KL25Z can only supply 4mA on its
mjr	5:a70c0bce770d	119	// output ports, so external hardware is required to take advantage of the LedWiz
mjr	5:a70c0bce770d	120	// emulation. Many different hardware designs are possible, but there's a simple
mjr	5:a70c0bce770d	121	// reference design in the documentation that uses a Darlington array IC to
mjr	5:a70c0bce770d	122	// increase the output from each port to 500mA (the same level as the LedWiz),
mjr	5:a70c0bce770d	123	// plus an extended design that adds an optocoupler and MOSFET to provide very
mjr	5:a70c0bce770d	124	// high power handling, up to about 45A or 150W, with voltages up to 100V.
mjr	5:a70c0bce770d	125	// That will handle just about any DC device directly (wtihout relays or other
mjr	5:a70c0bce770d	126	// amplifiers), and switches fast enough to support PWM devices.
mjr	5:a70c0bce770d	127	//
mjr	5:a70c0bce770d	128	// The device can report any desired LedWiz unit number to the host, which makes
mjr	5:a70c0bce770d	129	// it possible to use the LedWiz emulation on a machine that also has one or more
mjr	5:a70c0bce770d	130	// actual LedWiz devices intalled. The LedWiz design allows for up to 16 units
mjr	5:a70c0bce770d	131	// to be installed in one machine - each one is invidually addressable by its
mjr	5:a70c0bce770d	132	// distinct unit number.
mjr	5:a70c0bce770d	133	//
mjr	5:a70c0bce770d	134	// The LedWiz emulation features are of course optional. There's no need to
mjr	5:a70c0bce770d	135	// build any of the external port hardware (or attach anything to the output
mjr	5:a70c0bce770d	136	// ports at all) if the LedWiz features aren't needed. Most people won't have
mjr	5:a70c0bce770d	137	// any use for the LedWiz features. I built them mostly as a learning exercise,
mjr	5:a70c0bce770d	138	// but with a slight practical need for a handful of extra ports (I'm using the
mjr	5:a70c0bce770d	139	// cutting-edge 10-contactor setup, so my real LedWiz is full!).
mjr	6:cc35eb643e8f	140	//
mjr	6:cc35eb643e8f	141	// The on-board LED on the KL25Z flashes to indicate the current device status:
mjr	6:cc35eb643e8f	142	//
mjr	6:cc35eb643e8f	143	// two short red flashes = the device is powered but hasn't successfully
mjr	6:cc35eb643e8f	144	// connected to the host via USB (either it's not physically connected
mjr	6:cc35eb643e8f	145	// to the USB port, or there was a problem with the software handshake
mjr	6:cc35eb643e8f	146	// with the USB device driver on the computer)
mjr	6:cc35eb643e8f	147	//
mjr	6:cc35eb643e8f	148	// short red flash = the host computer is in sleep/suspend mode
mjr	6:cc35eb643e8f	149	//
mjr	6:cc35eb643e8f	150	// long red/green = the LedWiz unti number has been changed, so a reset
mjr	6:cc35eb643e8f	151	// is needed. You can simply unplug the device and plug it back in,
mjr	6:cc35eb643e8f	152	// or presss and hold the reset button on the device for a few seconds.
mjr	6:cc35eb643e8f	153	//
mjr	6:cc35eb643e8f	154	// long yellow/green = everything's working, but the plunger hasn't
mjr	6:cc35eb643e8f	155	// been calibrated; follow the calibration procedure described above.
mjr	6:cc35eb643e8f	156	// This flash mode won't appear if the CCD has been disabled. Note
mjr	6:cc35eb643e8f	157	// that the device can't tell whether a CCD is physically attached,
mjr	6:cc35eb643e8f	158	// so you should use the config command to disable the CCD software
mjr	6:cc35eb643e8f	159	// features if you won't be attaching a CCD.
mjr	6:cc35eb643e8f	160	//
mjr	6:cc35eb643e8f	161	// alternating blue/green = everything's working
mjr	6:cc35eb643e8f	162	//
mjr	6:cc35eb643e8f	163	// Software configuration: you can change option settings by sending special
mjr	6:cc35eb643e8f	164	// USB commands from the PC. I've provided a Windows program for this purpose;
mjr	6:cc35eb643e8f	165	// refer to the documentation for details. For reference, here's the format
mjr	6:cc35eb643e8f	166	// of the USB command for option changes:
mjr	6:cc35eb643e8f	167	//
mjr	6:cc35eb643e8f	168	// length of report = 8 bytes
mjr	6:cc35eb643e8f	169	// byte 0 = 65 (0x41)
mjr	6:cc35eb643e8f	170	// byte 1 = 1 (0x01)
mjr	6:cc35eb643e8f	171	// byte 2 = new LedWiz unit number, 0x01 to 0x0f
mjr	6:cc35eb643e8f	172	// byte 3 = feature enable bit mask:
mjr	6:cc35eb643e8f	173	// 0x01 = enable CCD (default = on)
mjr	9:fd65b0a94720	174	//
mjr	9:fd65b0a94720	175	// Plunger calibration mode: the host can activate plunger calibration mode
mjr	9:fd65b0a94720	176	// by sending this packet. This has the same effect as pressing and holding
mjr	9:fd65b0a94720	177	// the plunger calibration button for two seconds, to allow activating this
mjr	9:fd65b0a94720	178	// mode without attaching a physical button.
mjr	9:fd65b0a94720	179	//
mjr	9:fd65b0a94720	180	// length = 8 bytes
mjr	9:fd65b0a94720	181	// byte 0 = 65 (0x41)
mjr	9:fd65b0a94720	182	// byte 1 = 2 (0x02)
mjr	9:fd65b0a94720	183	//
mjr	10:976666ffa4ef	184	// Exposure reports: the host can request a report of the full set of pixel
mjr	10:976666ffa4ef	185	// values for the next frame by sending this special packet:
mjr	10:976666ffa4ef	186	//
mjr	10:976666ffa4ef	187	// length = 8 bytes
mjr	10:976666ffa4ef	188	// byte 0 = 65 (0x41)
mjr	10:976666ffa4ef	189	// byte 1 = 3 (0x03)
mjr	10:976666ffa4ef	190	//
mjr	10:976666ffa4ef	191	// We'll respond with a series of special reports giving the exposure status.
mjr	10:976666ffa4ef	192	// Each report has the following structure:
mjr	10:976666ffa4ef	193	//
mjr	10:976666ffa4ef	194	// bytes 0:1 = 11-bit index, with high 5 bits set to 10000. For
mjr	10:976666ffa4ef	195	// example, 0x04 0x80 indicates index 4. This is the
mjr	10:976666ffa4ef	196	// starting pixel number in the report. The first report
mjr	10:976666ffa4ef	197	// will be 0x00 0x80 to indicate pixel #0.
mjr	10:976666ffa4ef	198	// bytes 2:3 = 16-bit unsigned int brightness level of pixel at index
mjr	10:976666ffa4ef	199	// bytes 4:5 = brightness of pixel at index+1
mjr	10:976666ffa4ef	200	// etc for the rest of the packet
mjr	10:976666ffa4ef	201	//
mjr	10:976666ffa4ef	202	// This still has the form of a joystick packet at the USB level, but
mjr	10:976666ffa4ef	203	// can be differentiated by the host via the status bits. It would have
mjr	10:976666ffa4ef	204	// been cleaner to use a different Report ID at the USB level, but this
mjr	10:976666ffa4ef	205	// would have necessitated a different container structure in the report
mjr	10:976666ffa4ef	206	// descriptor, which would have broken LedWiz compatibility. Given that
mjr	10:976666ffa4ef	207	// constraint, we have to re-use the joystick report type, making for
mjr	10:976666ffa4ef	208	// this somewhat kludgey approach.
mjr	6:cc35eb643e8f	209
mjr	0:5acbbe3f4cf4	210	#include "mbed.h"
mjr	6:cc35eb643e8f	211	#include "math.h"
mjr	0:5acbbe3f4cf4	212	#include "USBJoystick.h"
mjr	0:5acbbe3f4cf4	213	#include "MMA8451Q.h"
mjr	1:d913e0afb2ac	214	#include "tsl1410r.h"
mjr	1:d913e0afb2ac	215	#include "FreescaleIAP.h"
mjr	2:c174f9ee414a	216	#include "crc32.h"
mjr	2:c174f9ee414a	217
mjr	5:a70c0bce770d	218
mjr	5:a70c0bce770d	219	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	220	//
mjr	5:a70c0bce770d	221	// Configuration details
mjr	5:a70c0bce770d	222	//
mjr	2:c174f9ee414a	223
mjr	5:a70c0bce770d	224	// Our USB device vendor ID, product ID, and version.
mjr	5:a70c0bce770d	225	// We use the vendor ID for the LedWiz, so that the PC-side software can
mjr	5:a70c0bce770d	226	// identify us as capable of performing LedWiz commands. The LedWiz uses
mjr	5:a70c0bce770d	227	// a product ID value from 0xF0 to 0xFF; the last four bits identify the
mjr	5:a70c0bce770d	228	// unit number (e.g., product ID 0xF7 means unit #7). This allows multiple
mjr	5:a70c0bce770d	229	// LedWiz units to be installed in a single PC; the software on the PC side
mjr	5:a70c0bce770d	230	// uses the unit number to route commands to the devices attached to each
mjr	5:a70c0bce770d	231	// unit. On the real LedWiz, the unit number must be set in the firmware
mjr	5:a70c0bce770d	232	// at the factory; it's not configurable by the end user. Most LedWiz's
mjr	5:a70c0bce770d	233	// ship with the unit number set to 0, but the vendor will set different
mjr	5:a70c0bce770d	234	// unit numbers if requested at the time of purchase. So if you have a
mjr	5:a70c0bce770d	235	// single LedWiz already installed in your cabinet, and you didn't ask for
mjr	5:a70c0bce770d	236	// a non-default unit number, your existing LedWiz will be unit 0.
mjr	5:a70c0bce770d	237	//
mjr	5:a70c0bce770d	238	// We use unit #7 by default. There doesn't seem to be a requirement that
mjr	5:a70c0bce770d	239	// unit numbers be contiguous (DirectOutput Framework and other software
mjr	5:a70c0bce770d	240	// seem happy to have units 0 and 7 installed, without 1-6 existing).
mjr	5:a70c0bce770d	241	// Marking this unit as #7 should work for almost everybody out of the box;
mjr	5:a70c0bce770d	242	// the most common case seems to be to have a single LedWiz installed, and
mjr	5:a70c0bce770d	243	// it's probably extremely rare to more than two.
mjr	6:cc35eb643e8f	244	//
mjr	6:cc35eb643e8f	245	// Note that the USB_PRODUCT_ID value set here omits the unit number. We
mjr	6:cc35eb643e8f	246	// take the unit number from the saved configuration. We provide a
mjr	6:cc35eb643e8f	247	// configuration command that can be sent via the USB connection to change
mjr	6:cc35eb643e8f	248	// the unit number, so that users can select the unit number without having
mjr	6:cc35eb643e8f	249	// to install a different version of the software. We'll combine the base
mjr	6:cc35eb643e8f	250	// product ID here with the unit number to get the actual product ID that
mjr	6:cc35eb643e8f	251	// we send to the USB controller.
mjr	5:a70c0bce770d	252	const uint16_t USB_VENDOR_ID = 0xFAFA;
mjr	6:cc35eb643e8f	253	const uint16_t USB_PRODUCT_ID = 0x00F0;
mjr	6:cc35eb643e8f	254	const uint16_t USB_VERSION_NO = 0x0006;
mjr	6:cc35eb643e8f	255	const uint8_t DEFAULT_LEDWIZ_UNIT_NUMBER = 0x07;
mjr	0:5acbbe3f4cf4	256
mjr	9:fd65b0a94720	257	// Number of pixels we read from the sensor on each frame. This can be
mjr	9:fd65b0a94720	258	// less than the physical pixel count if desired; we'll read every nth
mjr	9:fd65b0a94720	259	// piexl if so. E.g., with a 1280-pixel physical sensor, if npix is 320,
mjr	9:fd65b0a94720	260	// we'll read every 4th pixel. It takes time to read each pixel, so the
mjr	9:fd65b0a94720	261	// fewer pixels we read, the higher the refresh rate we can achieve.
mjr	9:fd65b0a94720	262	// It's therefore better not to read more pixels than we have to.
mjr	9:fd65b0a94720	263	//
mjr	9:fd65b0a94720	264	// VP seems to have an internal resolution in the 8-bit range, so there's
mjr	9:fd65b0a94720	265	// no apparent benefit to reading more than 128-256 pixels when using VP.
mjr	9:fd65b0a94720	266	// Empirically, 160 pixels seems about right. The overall travel of a
mjr	9:fd65b0a94720	267	// standard pinball plunger is about 3", so 160 pixels gives us resolution
mjr	9:fd65b0a94720	268	// of about 1/50". This seems to take full advantage of VP's modeling
mjr	9:fd65b0a94720	269	// ability, and is probably also more precise than a human player's
mjr	9:fd65b0a94720	270	// perception of the plunger position.
mjr	9:fd65b0a94720	271	const int npix = 160;
mjr	9:fd65b0a94720	272
mjr	4:02c7cd7b2183	273	// On-board RGB LED elements - we use these for diagnostic displays.
mjr	4:02c7cd7b2183	274	DigitalOut ledR(LED1), ledG(LED2), ledB(LED3);
mjr	0:5acbbe3f4cf4	275
mjr	1:d913e0afb2ac	276	// calibration button - switch input and LED output
mjr	1:d913e0afb2ac	277	DigitalIn calBtn(PTE29);
mjr	1:d913e0afb2ac	278	DigitalOut calBtnLed(PTE23);
mjr	0:5acbbe3f4cf4	279
mjr	6:cc35eb643e8f	280	// LED-Wiz emulation output pin assignments. The LED-Wiz protocol
mjr	6:cc35eb643e8f	281	// can support up to 32 outputs. The KL25Z can physically provide
mjr	6:cc35eb643e8f	282	// about 48 (in addition to the ports we're already using for the
mjr	6:cc35eb643e8f	283	// CCD sensor and the calibration button), but to stay compatible
mjr	6:cc35eb643e8f	284	// with the LED-Wiz protocol we'll stop at 32.
mjr	6:cc35eb643e8f	285	//
mjr	6:cc35eb643e8f	286	// The LED-Wiz protocol allows setting individual intensity levels
mjr	6:cc35eb643e8f	287	// on all outputs, with 48 levels of intensity. This can be used
mjr	6:cc35eb643e8f	288	// to control lamp brightness and motor speeds, among other things.
mjr	6:cc35eb643e8f	289	// Unfortunately, the KL25Z only has 10 PWM channels, so while we
mjr	6:cc35eb643e8f	290	// can support the full complement of 32 outputs, we can only provide
mjr	6:cc35eb643e8f	291	// PWM dimming/speed control on 10 of them. The remaining outputs
mjr	6:cc35eb643e8f	292	// can only be switched fully on and fully off - we can't support
mjr	6:cc35eb643e8f	293	// dimming on these, so they'll ignore any intensity level setting
mjr	6:cc35eb643e8f	294	// requested by the host. Use these for devices that don't have any
mjr	6:cc35eb643e8f	295	// use for intensity settings anyway, such as contactors and knockers.
mjr	6:cc35eb643e8f	296	//
mjr	6:cc35eb643e8f	297	// The mapping between physical output pins on the KL25Z and the
mjr	6:cc35eb643e8f	298	// assigned LED-Wiz port numbers is essentially arbitrary - you can
mjr	6:cc35eb643e8f	299	// customize this by changing the entries in the array below if you
mjr	6:cc35eb643e8f	300	// wish to rearrange the pins for any reason. Be aware that some
mjr	6:cc35eb643e8f	301	// of the physical outputs are already used for other purposes
mjr	6:cc35eb643e8f	302	// (e.g., some of the GPIO pins on header J10 are used for the
mjr	6:cc35eb643e8f	303	// CCD sensor - but you can of course reassign those as well by
mjr	6:cc35eb643e8f	304	// changing the corresponding declarations elsewhere in this module).
mjr	6:cc35eb643e8f	305	// The assignments we make here have two main objectives: first,
mjr	6:cc35eb643e8f	306	// to group the outputs on headers J1 and J2 (to facilitate neater
mjr	6:cc35eb643e8f	307	// wiring by keeping the output pins together physically), and
mjr	6:cc35eb643e8f	308	// second, to make the physical pin layout match the LED-Wiz port
mjr	6:cc35eb643e8f	309	// numbering order to the extent possible. There's one big wrench
mjr	6:cc35eb643e8f	310	// in the works, though, which is the limited number and discontiguous
mjr	6:cc35eb643e8f	311	// placement of the KL25Z PWM-capable output pins. This prevents
mjr	6:cc35eb643e8f	312	// us from doing the most obvious sequential ordering of the pins,
mjr	6:cc35eb643e8f	313	// so we end up with the outputs arranged into several blocks.
mjr	6:cc35eb643e8f	314	// Hopefully this isn't too confusing; for more detailed rationale,
mjr	6:cc35eb643e8f	315	// read on...
mjr	6:cc35eb643e8f	316	//
mjr	6:cc35eb643e8f	317	// With the LED-Wiz, the host software configuration usually
mjr	6:cc35eb643e8f	318	// assumes that each RGB LED is hooked up to three consecutive ports
mjr	6:cc35eb643e8f	319	// (for the red, green, and blue components, which need to be
mjr	6:cc35eb643e8f	320	// physically wired to separate outputs to allow each color to be
mjr	6:cc35eb643e8f	321	// controlled independently). To facilitate this, we arrange the
mjr	6:cc35eb643e8f	322	// PWM-enabled outputs so that they're grouped together in the
mjr	6:cc35eb643e8f	323	// port numbering scheme. Unfortunately, these outputs aren't
mjr	6:cc35eb643e8f	324	// together in a single group in the physical pin layout, so to
mjr	6:cc35eb643e8f	325	// group them logically in the LED-Wiz port numbering scheme, we
mjr	6:cc35eb643e8f	326	// have to break up the overall numbering scheme into several blocks.
mjr	6:cc35eb643e8f	327	// So our port numbering goes sequentially down each column of
mjr	6:cc35eb643e8f	328	// header pins, but there are several break points where we have
mjr	6:cc35eb643e8f	329	// to interrupt the obvious sequence to keep the PWM pins grouped
mjr	6:cc35eb643e8f	330	// logically.
mjr	6:cc35eb643e8f	331	//
mjr	6:cc35eb643e8f	332	// In the list below, "pin J1-2" refers to pin 2 on header J1 on
mjr	6:cc35eb643e8f	333	// the KL25Z, using the standard pin numbering in the KL25Z
mjr	6:cc35eb643e8f	334	// documentation - this is the physical pin that the port controls.
mjr	6:cc35eb643e8f	335	// "LW port 1" means LED-Wiz port 1 - this is the LED-Wiz port
mjr	6:cc35eb643e8f	336	// number that you use on the PC side (in the DirectOutput config
mjr	6:cc35eb643e8f	337	// file, for example) to address the port. PWM-capable ports are
mjr	6:cc35eb643e8f	338	// marked as such - we group the PWM-capable ports into the first
mjr	6:cc35eb643e8f	339	// 10 LED-Wiz port numbers.
mjr	6:cc35eb643e8f	340	//
mjr	6:cc35eb643e8f	341	struct {
mjr	6:cc35eb643e8f	342	PinName pin;
mjr	6:cc35eb643e8f	343	bool isPWM;
mjr	6:cc35eb643e8f	344	} ledWizPortMap[32] = {
mjr	6:cc35eb643e8f	345	{ PTA1, true }, // pin J1-2, LW port 1 (PWM capable - TPM 2.0 = channel 9)
mjr	6:cc35eb643e8f	346	{ PTA2, true }, // pin J1-4, LW port 2 (PWM capable - TPM 2.1 = channel 10)
mjr	6:cc35eb643e8f	347	{ PTD4, true }, // pin J1-6, LW port 3 (PWM capable - TPM 0.4 = channel 5)
mjr	6:cc35eb643e8f	348	{ PTA12, true }, // pin J1-8, LW port 4 (PWM capable - TPM 1.0 = channel 7)
mjr	6:cc35eb643e8f	349	{ PTA4, true }, // pin J1-10, LW port 5 (PWM capable - TPM 0.1 = channel 2)
mjr	6:cc35eb643e8f	350	{ PTA5, true }, // pin J1-12, LW port 6 (PWM capable - TPM 0.2 = channel 3)
mjr	6:cc35eb643e8f	351	{ PTA13, true }, // pin J2-2, LW port 7 (PWM capable - TPM 1.1 = channel 13)
mjr	6:cc35eb643e8f	352	{ PTD5, true }, // pin J2-4, LW port 8 (PWM capable - TPM 0.5 = channel 6)
mjr	6:cc35eb643e8f	353	{ PTD0, true }, // pin J2-6, LW port 9 (PWM capable - TPM 0.0 = channel 1)
mjr	6:cc35eb643e8f	354	{ PTD3, true }, // pin J2-10, LW port 10 (PWM capable - TPM 0.3 = channel 4)
mjr	9:fd65b0a94720	355	{ PTD2, false }, // pin J2-8, LW port 11
mjr	9:fd65b0a94720	356	{ PTC8, false }, // pin J1-14, LW port 12
mjr	9:fd65b0a94720	357	{ PTC9, false }, // pin J1-16, LW port 13
mjr	9:fd65b0a94720	358	{ PTC7, false }, // pin J1-1, LW port 14
mjr	9:fd65b0a94720	359	{ PTC0, false }, // pin J1-3, LW port 15
mjr	9:fd65b0a94720	360	{ PTC3, false }, // pin J1-5, LW port 16
mjr	9:fd65b0a94720	361	{ PTC4, false }, // pin J1-7, LW port 17
mjr	9:fd65b0a94720	362	{ PTC5, false }, // pin J1-9, LW port 18
mjr	9:fd65b0a94720	363	{ PTC6, false }, // pin J1-11, LW port 19
mjr	9:fd65b0a94720	364	{ PTC10, false }, // pin J1-13, LW port 20
mjr	9:fd65b0a94720	365	{ PTC11, false }, // pin J1-15, LW port 21
mjr	9:fd65b0a94720	366	{ PTC12, false }, // pin J2-1, LW port 22
mjr	9:fd65b0a94720	367	{ PTC13, false }, // pin J2-3, LW port 23
mjr	9:fd65b0a94720	368	{ PTC16, false }, // pin J2-5, LW port 24
mjr	9:fd65b0a94720	369	{ PTC17, false }, // pin J2-7, LW port 25
mjr	9:fd65b0a94720	370	{ PTA16, false }, // pin J2-9, LW port 26
mjr	9:fd65b0a94720	371	{ PTA17, false }, // pin J2-11, LW port 27
mjr	9:fd65b0a94720	372	{ PTE31, false }, // pin J2-13, LW port 28
mjr	6:cc35eb643e8f	373	{ PTD6, false }, // pin J2-17, LW port 29
mjr	6:cc35eb643e8f	374	{ PTD7, false }, // pin J2-19, LW port 30
mjr	6:cc35eb643e8f	375	{ PTE0, false }, // pin J2-18, LW port 31
mjr	6:cc35eb643e8f	376	{ PTE1, false } // pin J2-20, LW port 32
mjr	6:cc35eb643e8f	377	};
mjr	6:cc35eb643e8f	378
mjr	6:cc35eb643e8f	379
mjr	5:a70c0bce770d	380	// I2C address of the accelerometer (this is a constant of the KL25Z)
mjr	5:a70c0bce770d	381	const int MMA8451_I2C_ADDRESS = (0x1d<<1);
mjr	5:a70c0bce770d	382
mjr	5:a70c0bce770d	383	// SCL and SDA pins for the accelerometer (constant for the KL25Z)
mjr	5:a70c0bce770d	384	#define MMA8451_SCL_PIN PTE25
mjr	5:a70c0bce770d	385	#define MMA8451_SDA_PIN PTE24
mjr	5:a70c0bce770d	386
mjr	5:a70c0bce770d	387	// Digital in pin to use for the accelerometer interrupt. For the KL25Z,
mjr	5:a70c0bce770d	388	// this can be either PTA14 or PTA15, since those are the pins physically
mjr	5:a70c0bce770d	389	// wired on this board to the MMA8451 interrupt controller.
mjr	5:a70c0bce770d	390	#define MMA8451_INT_PIN PTA15
mjr	5:a70c0bce770d	391
mjr	6:cc35eb643e8f	392	// Joystick axis report range - we report from -JOYMAX to +JOYMAX
mjr	6:cc35eb643e8f	393	#define JOYMAX 4096
mjr	6:cc35eb643e8f	394
mjr	5:a70c0bce770d	395
mjr	5:a70c0bce770d	396	// ---------------------------------------------------------------------------
mjr	9:fd65b0a94720	397	// utilities
mjr	9:fd65b0a94720	398
mjr	9:fd65b0a94720	399	// number of elements in an array
mjr	9:fd65b0a94720	400	#define countof(x) (sizeof(x)/sizeof((x)[0]))
mjr	9:fd65b0a94720	401
mjr	9:fd65b0a94720	402	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	403	//
mjr	5:a70c0bce770d	404	// LedWiz emulation
mjr	5:a70c0bce770d	405	//
mjr	5:a70c0bce770d	406
mjr	0:5acbbe3f4cf4	407	static int pbaIdx = 0;
mjr	0:5acbbe3f4cf4	408
mjr	6:cc35eb643e8f	409	// LedWiz output pin interface. We create a cover class to virtualize
mjr	6:cc35eb643e8f	410	// digital vs PWM outputs and give them a common interface. The KL25Z
mjr	6:cc35eb643e8f	411	// unfortunately doesn't have enough hardware PWM channels to support
mjr	6:cc35eb643e8f	412	// PWM on all 32 LedWiz outputs, so we provide as many PWM channels as
mjr	6:cc35eb643e8f	413	// we can (10), and fill out the rest of the outputs with plain digital
mjr	6:cc35eb643e8f	414	// outs.
mjr	6:cc35eb643e8f	415	class LwOut
mjr	6:cc35eb643e8f	416	{
mjr	6:cc35eb643e8f	417	public:
mjr	6:cc35eb643e8f	418	virtual void set(float val) = 0;
mjr	6:cc35eb643e8f	419	};
mjr	6:cc35eb643e8f	420	class LwPwmOut: public LwOut
mjr	6:cc35eb643e8f	421	{
mjr	6:cc35eb643e8f	422	public:
mjr	6:cc35eb643e8f	423	LwPwmOut(PinName pin) : p(pin) { }
mjr	6:cc35eb643e8f	424	virtual void set(float val) { p = val; }
mjr	6:cc35eb643e8f	425	PwmOut p;
mjr	6:cc35eb643e8f	426	};
mjr	6:cc35eb643e8f	427	class LwDigOut: public LwOut
mjr	6:cc35eb643e8f	428	{
mjr	6:cc35eb643e8f	429	public:
mjr	6:cc35eb643e8f	430	LwDigOut(PinName pin) : p(pin) { }
mjr	6:cc35eb643e8f	431	virtual void set(float val) { p = val; }
mjr	6:cc35eb643e8f	432	DigitalOut p;
mjr	6:cc35eb643e8f	433	};
mjr	6:cc35eb643e8f	434
mjr	6:cc35eb643e8f	435	// output pin array
mjr	6:cc35eb643e8f	436	static LwOut *lwPin[32];
mjr	6:cc35eb643e8f	437
mjr	6:cc35eb643e8f	438	// initialize the output pin array
mjr	6:cc35eb643e8f	439	void initLwOut()
mjr	6:cc35eb643e8f	440	{
mjr	9:fd65b0a94720	441	for (int i = 0 ; i < countof(lwPin) ; ++i)
mjr	6:cc35eb643e8f	442	{
mjr	6:cc35eb643e8f	443	PinName p = ledWizPortMap[i].pin;
mjr	6:cc35eb643e8f	444	lwPin[i] = (ledWizPortMap[i].isPWM
mjr	6:cc35eb643e8f	445	? (LwOut *)new LwPwmOut(p)
mjr	6:cc35eb643e8f	446	: (LwOut *)new LwDigOut(p));
mjr	6:cc35eb643e8f	447	}
mjr	6:cc35eb643e8f	448	}
mjr	6:cc35eb643e8f	449
mjr	0:5acbbe3f4cf4	450	// on/off state for each LedWiz output
mjr	1:d913e0afb2ac	451	static uint8_t wizOn[32];
mjr	0:5acbbe3f4cf4	452
mjr	0:5acbbe3f4cf4	453	// profile (brightness/blink) state for each LedWiz output
mjr	1:d913e0afb2ac	454	static uint8_t wizVal[32] = {
mjr	0:5acbbe3f4cf4	455	0, 0, 0, 0, 0, 0, 0, 0,
mjr	0:5acbbe3f4cf4	456	0, 0, 0, 0, 0, 0, 0, 0,
mjr	0:5acbbe3f4cf4	457	0, 0, 0, 0, 0, 0, 0, 0,
mjr	0:5acbbe3f4cf4	458	0, 0, 0, 0, 0, 0, 0, 0
mjr	0:5acbbe3f4cf4	459	};
mjr	0:5acbbe3f4cf4	460
mjr	1:d913e0afb2ac	461	static float wizState(int idx)
mjr	0:5acbbe3f4cf4	462	{
mjr	1:d913e0afb2ac	463	if (wizOn[idx]) {
mjr	0:5acbbe3f4cf4	464	// on - map profile brightness state to PWM level
mjr	1:d913e0afb2ac	465	uint8_t val = wizVal[idx];
mjr	0:5acbbe3f4cf4	466	if (val >= 1 && val <= 48)
mjr	0:5acbbe3f4cf4	467	return 1.0 - val/48.0;
mjr	0:5acbbe3f4cf4	468	else if (val >= 129 && val <= 132)
mjr	0:5acbbe3f4cf4	469	return 0.0;
mjr	0:5acbbe3f4cf4	470	else
mjr	0:5acbbe3f4cf4	471	return 1.0;
mjr	0:5acbbe3f4cf4	472	}
mjr	0:5acbbe3f4cf4	473	else {
mjr	0:5acbbe3f4cf4	474	// off
mjr	0:5acbbe3f4cf4	475	return 1.0;
mjr	0:5acbbe3f4cf4	476	}
mjr	0:5acbbe3f4cf4	477	}
mjr	0:5acbbe3f4cf4	478
mjr	1:d913e0afb2ac	479	static void updateWizOuts()
mjr	1:d913e0afb2ac	480	{
mjr	6:cc35eb643e8f	481	for (int i = 0 ; i < 32 ; ++i)
mjr	6:cc35eb643e8f	482	lwPin[i]->set(wizState(i));
mjr	1:d913e0afb2ac	483	}
mjr	1:d913e0afb2ac	484
mjr	5:a70c0bce770d	485	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	486	//
mjr	5:a70c0bce770d	487	// Non-volatile memory (NVM)
mjr	5:a70c0bce770d	488	//
mjr	0:5acbbe3f4cf4	489
mjr	5:a70c0bce770d	490	// Structure defining our NVM storage layout. We store a small
mjr	2:c174f9ee414a	491	// amount of persistent data in flash memory to retain calibration
mjr	5:a70c0bce770d	492	// data when powered off.
mjr	2:c174f9ee414a	493	struct NVM
mjr	2:c174f9ee414a	494	{
mjr	2:c174f9ee414a	495	// checksum - we use this to determine if the flash record
mjr	6:cc35eb643e8f	496	// has been properly initialized
mjr	2:c174f9ee414a	497	uint32_t checksum;
mjr	2:c174f9ee414a	498
mjr	2:c174f9ee414a	499	// signature value
mjr	2:c174f9ee414a	500	static const uint32_t SIGNATURE = 0x4D4A522A;
mjr	6:cc35eb643e8f	501	static const uint16_t VERSION = 0x0003;
mjr	6:cc35eb643e8f	502
mjr	6:cc35eb643e8f	503	// Is the data structure valid? We test the signature and
mjr	6:cc35eb643e8f	504	// checksum to determine if we've been properly stored.
mjr	6:cc35eb643e8f	505	int valid() const
mjr	6:cc35eb643e8f	506	{
mjr	6:cc35eb643e8f	507	return (d.sig == SIGNATURE
mjr	6:cc35eb643e8f	508	&& d.vsn == VERSION
mjr	6:cc35eb643e8f	509	&& d.sz == sizeof(NVM)
mjr	6:cc35eb643e8f	510	&& checksum == CRC32(&d, sizeof(d)));
mjr	6:cc35eb643e8f	511	}
mjr	6:cc35eb643e8f	512
mjr	6:cc35eb643e8f	513	// save to non-volatile memory
mjr	6:cc35eb643e8f	514	void save(FreescaleIAP &iap, int addr)
mjr	6:cc35eb643e8f	515	{
mjr	6:cc35eb643e8f	516	// update the checksum and structure size
mjr	6:cc35eb643e8f	517	checksum = CRC32(&d, sizeof(d));
mjr	6:cc35eb643e8f	518	d.sz = sizeof(NVM);
mjr	6:cc35eb643e8f	519
mjr	6:cc35eb643e8f	520	// erase the sector
mjr	6:cc35eb643e8f	521	iap.erase_sector(addr);
mjr	6:cc35eb643e8f	522
mjr	6:cc35eb643e8f	523	// save the data
mjr	6:cc35eb643e8f	524	iap.program_flash(addr, this, sizeof(*this));
mjr	6:cc35eb643e8f	525	}
mjr	2:c174f9ee414a	526
mjr	9:fd65b0a94720	527	// reset calibration data for calibration mode
mjr	9:fd65b0a94720	528	void resetPlunger()
mjr	9:fd65b0a94720	529	{
mjr	9:fd65b0a94720	530	// set extremes for the calibration data
mjr	9:fd65b0a94720	531	d.plungerMax = 0;
mjr	9:fd65b0a94720	532	d.plungerZero = npix;
mjr	9:fd65b0a94720	533	d.plungerMin = npix;
mjr	9:fd65b0a94720	534	}
mjr	9:fd65b0a94720	535
mjr	2:c174f9ee414a	536	// stored data (excluding the checksum)
mjr	2:c174f9ee414a	537	struct
mjr	2:c174f9ee414a	538	{
mjr	6:cc35eb643e8f	539	// Signature, structure version, and structure size - further verification
mjr	6:cc35eb643e8f	540	// that we have valid initialized data. The size is a simple proxy for a
mjr	6:cc35eb643e8f	541	// structure version, as the most common type of change to the structure as
mjr	6:cc35eb643e8f	542	// the software evolves will be the addition of new elements. We also
mjr	6:cc35eb643e8f	543	// provide an explicit version number that we can update manually if we
mjr	6:cc35eb643e8f	544	// make any changes that don't affect the structure size but would affect
mjr	6:cc35eb643e8f	545	// compatibility with a saved record (e.g., swapping two existing elements).
mjr	2:c174f9ee414a	546	uint32_t sig;
mjr	2:c174f9ee414a	547	uint16_t vsn;
mjr	6:cc35eb643e8f	548	int sz;
mjr	2:c174f9ee414a	549
mjr	6:cc35eb643e8f	550	// has the plunger been manually calibrated?
mjr	6:cc35eb643e8f	551	int plungerCal;
mjr	6:cc35eb643e8f	552
mjr	2:c174f9ee414a	553	// plunger calibration min and max
mjr	2:c174f9ee414a	554	int plungerMin;
mjr	6:cc35eb643e8f	555	int plungerZero;
mjr	2:c174f9ee414a	556	int plungerMax;
mjr	6:cc35eb643e8f	557
mjr	6:cc35eb643e8f	558	// is the CCD enabled?
mjr	6:cc35eb643e8f	559	int ccdEnabled;
mjr	6:cc35eb643e8f	560
mjr	6:cc35eb643e8f	561	// LedWiz unit number
mjr	6:cc35eb643e8f	562	uint8_t ledWizUnitNo;
mjr	2:c174f9ee414a	563	} d;
mjr	2:c174f9ee414a	564	};
mjr	2:c174f9ee414a	565
mjr	5:a70c0bce770d	566
mjr	5:a70c0bce770d	567	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	568	//
mjr	5:a70c0bce770d	569	// Customization joystick subbclass
mjr	5:a70c0bce770d	570	//
mjr	5:a70c0bce770d	571
mjr	5:a70c0bce770d	572	class MyUSBJoystick: public USBJoystick
mjr	5:a70c0bce770d	573	{
mjr	5:a70c0bce770d	574	public:
mjr	5:a70c0bce770d	575	MyUSBJoystick(uint16_t vendor_id, uint16_t product_id, uint16_t product_release)
mjr	5:a70c0bce770d	576	: USBJoystick(vendor_id, product_id, product_release, true)
mjr	5:a70c0bce770d	577	{
mjr	5:a70c0bce770d	578	suspended_ = false;
mjr	5:a70c0bce770d	579	}
mjr	5:a70c0bce770d	580
mjr	5:a70c0bce770d	581	// are we connected?
mjr	5:a70c0bce770d	582	int isConnected() { return configured(); }
mjr	5:a70c0bce770d	583
mjr	5:a70c0bce770d	584	// Are we in suspend mode?
mjr	5:a70c0bce770d	585	int isSuspended() const { return suspended_; }
mjr	5:a70c0bce770d	586
mjr	5:a70c0bce770d	587	protected:
mjr	5:a70c0bce770d	588	virtual void suspendStateChanged(unsigned int suspended)
mjr	5:a70c0bce770d	589	{ suspended_ = suspended; }
mjr	5:a70c0bce770d	590
mjr	5:a70c0bce770d	591	// are we suspended?
mjr	5:a70c0bce770d	592	int suspended_;
mjr	5:a70c0bce770d	593	};
mjr	5:a70c0bce770d	594
mjr	5:a70c0bce770d	595	// ---------------------------------------------------------------------------
mjr	6:cc35eb643e8f	596	//
mjr	6:cc35eb643e8f	597	// Some simple math service routines
mjr	6:cc35eb643e8f	598	//
mjr	6:cc35eb643e8f	599
mjr	6:cc35eb643e8f	600	inline float square(float x) { return x*x; }
mjr	6:cc35eb643e8f	601	inline float round(float x) { return x > 0 ? floor(x + 0.5) : ceil(x - 0.5); }
mjr	6:cc35eb643e8f	602
mjr	6:cc35eb643e8f	603	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	604	//
mjr	5:a70c0bce770d	605	// Accelerometer (MMA8451Q)
mjr	5:a70c0bce770d	606	//
mjr	5:a70c0bce770d	607
mjr	5:a70c0bce770d	608	// The MMA8451Q is the KL25Z's on-board 3-axis accelerometer.
mjr	5:a70c0bce770d	609	//
mjr	5:a70c0bce770d	610	// This is a custom wrapper for the library code to interface to the
mjr	6:cc35eb643e8f	611	// MMA8451Q. This class encapsulates an interrupt handler and
mjr	6:cc35eb643e8f	612	// automatic calibration.
mjr	5:a70c0bce770d	613	//
mjr	5:a70c0bce770d	614	// We install an interrupt handler on the accelerometer "data ready"
mjr	6:cc35eb643e8f	615	// interrupt to ensure that we fetch each sample immediately when it
mjr	6:cc35eb643e8f	616	// becomes available. The accelerometer data rate is fiarly high
mjr	6:cc35eb643e8f	617	// (800 Hz), so it's not practical to keep up with it by polling.
mjr	6:cc35eb643e8f	618	// Using an interrupt handler lets us respond quickly and read
mjr	6:cc35eb643e8f	619	// every sample.
mjr	5:a70c0bce770d	620	//
mjr	6:cc35eb643e8f	621	// We automatically calibrate the accelerometer so that it's not
mjr	6:cc35eb643e8f	622	// necessary to get it exactly level when installing it, and so
mjr	6:cc35eb643e8f	623	// that it's also not necessary to calibrate it manually. There's
mjr	6:cc35eb643e8f	624	// lots of experience that tells us that manual calibration is a
mjr	6:cc35eb643e8f	625	// terrible solution, mostly because cabinets tend to shift slightly
mjr	6:cc35eb643e8f	626	// during use, requiring frequent recalibration. Instead, we
mjr	6:cc35eb643e8f	627	// calibrate automatically. We continuously monitor the acceleration
mjr	6:cc35eb643e8f	628	// data, watching for periods of constant (or nearly constant) values.
mjr	6:cc35eb643e8f	629	// Any time it appears that the machine has been at rest for a while
mjr	6:cc35eb643e8f	630	// (about 5 seconds), we'll average the readings during that rest
mjr	6:cc35eb643e8f	631	// period and use the result as the level rest position. This is
mjr	6:cc35eb643e8f	632	// is ongoing, so we'll quickly find the center point again if the
mjr	6:cc35eb643e8f	633	// machine is moved during play (by an especially aggressive bout
mjr	6:cc35eb643e8f	634	// of nudging, say).
mjr	5:a70c0bce770d	635	//
mjr	5:a70c0bce770d	636
mjr	6:cc35eb643e8f	637	// accelerometer input history item, for gathering calibration data
mjr	6:cc35eb643e8f	638	struct AccHist
mjr	5:a70c0bce770d	639	{
mjr	6:cc35eb643e8f	640	AccHist() { x = y = d = 0.0; xtot = ytot = 0.0; cnt = 0; }
mjr	6:cc35eb643e8f	641	void set(float x, float y, AccHist *prv)
mjr	6:cc35eb643e8f	642	{
mjr	6:cc35eb643e8f	643	// save the raw position
mjr	6:cc35eb643e8f	644	this->x = x;
mjr	6:cc35eb643e8f	645	this->y = y;
mjr	6:cc35eb643e8f	646	this->d = distance(prv);
mjr	6:cc35eb643e8f	647	}
mjr	6:cc35eb643e8f	648
mjr	6:cc35eb643e8f	649	// reading for this entry
mjr	5:a70c0bce770d	650	float x, y;
mjr	5:a70c0bce770d	651
mjr	6:cc35eb643e8f	652	// distance from previous entry
mjr	6:cc35eb643e8f	653	float d;
mjr	5:a70c0bce770d	654
mjr	6:cc35eb643e8f	655	// total and count of samples averaged over this period
mjr	6:cc35eb643e8f	656	float xtot, ytot;
mjr	6:cc35eb643e8f	657	int cnt;
mjr	6:cc35eb643e8f	658
mjr	6:cc35eb643e8f	659	void clearAvg() { xtot = ytot = 0.0; cnt = 0; }
mjr	6:cc35eb643e8f	660	void addAvg(float x, float y) { xtot += x; ytot += y; ++cnt; }
mjr	6:cc35eb643e8f	661	float xAvg() const { return xtot/cnt; }
mjr	6:cc35eb643e8f	662	float yAvg() const { return ytot/cnt; }
mjr	5:a70c0bce770d	663
mjr	6:cc35eb643e8f	664	float distance(AccHist *p)
mjr	6:cc35eb643e8f	665	{ return sqrt(square(p->x - x) + square(p->y - y)); }
mjr	5:a70c0bce770d	666	};
mjr	5:a70c0bce770d	667
mjr	5:a70c0bce770d	668	// accelerometer wrapper class
mjr	3:3514575d4f86	669	class Accel
mjr	3:3514575d4f86	670	{
mjr	3:3514575d4f86	671	public:
mjr	3:3514575d4f86	672	Accel(PinName sda, PinName scl, int i2cAddr, PinName irqPin)
mjr	3:3514575d4f86	673	: mma_(sda, scl, i2cAddr), intIn_(irqPin)
mjr	3:3514575d4f86	674	{
mjr	5:a70c0bce770d	675	// remember the interrupt pin assignment
mjr	5:a70c0bce770d	676	irqPin_ = irqPin;
mjr	5:a70c0bce770d	677
mjr	5:a70c0bce770d	678	// reset and initialize
mjr	5:a70c0bce770d	679	reset();
mjr	5:a70c0bce770d	680	}
mjr	5:a70c0bce770d	681
mjr	5:a70c0bce770d	682	void reset()
mjr	5:a70c0bce770d	683	{
mjr	6:cc35eb643e8f	684	// clear the center point
mjr	6:cc35eb643e8f	685	cx_ = cy_ = 0.0;
mjr	6:cc35eb643e8f	686
mjr	6:cc35eb643e8f	687	// start the calibration timer
mjr	5:a70c0bce770d	688	tCenter_.start();
mjr	5:a70c0bce770d	689	iAccPrv_ = nAccPrv_ = 0;
mjr	6:cc35eb643e8f	690
mjr	5:a70c0bce770d	691	// reset and initialize the MMA8451Q
mjr	5:a70c0bce770d	692	mma_.init();
mjr	6:cc35eb643e8f	693
mjr	6:cc35eb643e8f	694	// set the initial integrated velocity reading to zero
mjr	6:cc35eb643e8f	695	vx_ = vy_ = 0;
mjr	3:3514575d4f86	696
mjr	6:cc35eb643e8f	697	// set up our accelerometer interrupt handling
mjr	6:cc35eb643e8f	698	intIn_.rise(this, &Accel::isr);
mjr	5:a70c0bce770d	699	mma_.setInterruptMode(irqPin_ == PTA14 ? 1 : 2);
mjr	3:3514575d4f86	700
mjr	3:3514575d4f86	701	// read the current registers to clear the data ready flag
mjr	6:cc35eb643e8f	702	mma_.getAccXYZ(ax_, ay_, az_);
mjr	3:3514575d4f86	703
mjr	3:3514575d4f86	704	// start our timers
mjr	3:3514575d4f86	705	tGet_.start();
mjr	3:3514575d4f86	706	tInt_.start();
mjr	3:3514575d4f86	707	}
mjr	3:3514575d4f86	708
mjr	9:fd65b0a94720	709	void get(int &x, int &y)
mjr	3:3514575d4f86	710	{
mjr	3:3514575d4f86	711	// disable interrupts while manipulating the shared data
mjr	3:3514575d4f86	712	__disable_irq();
mjr	3:3514575d4f86	713
mjr	3:3514575d4f86	714	// read the shared data and store locally for calculations
mjr	6:cc35eb643e8f	715	float ax = ax_, ay = ay_;
mjr	6:cc35eb643e8f	716	float vx = vx_, vy = vy_;
mjr	5:a70c0bce770d	717
mjr	6:cc35eb643e8f	718	// reset the velocity sum for the next run
mjr	6:cc35eb643e8f	719	vx_ = vy_ = 0;
mjr	3:3514575d4f86	720
mjr	3:3514575d4f86	721	// get the time since the last get() sample
mjr	3:3514575d4f86	722	float dt = tGet_.read_us()/1.0e6;
mjr	3:3514575d4f86	723	tGet_.reset();
mjr	3:3514575d4f86	724
mjr	3:3514575d4f86	725	// done manipulating the shared data
mjr	3:3514575d4f86	726	__enable_irq();
mjr	3:3514575d4f86	727
mjr	6:cc35eb643e8f	728	// adjust the readings for the integration time
mjr	6:cc35eb643e8f	729	vx /= dt;
mjr	6:cc35eb643e8f	730	vy /= dt;
mjr	6:cc35eb643e8f	731
mjr	6:cc35eb643e8f	732	// add this sample to the current calibration interval's running total
mjr	6:cc35eb643e8f	733	AccHist *p = accPrv_ + iAccPrv_;
mjr	6:cc35eb643e8f	734	p->addAvg(ax, ay);
mjr	6:cc35eb643e8f	735
mjr	5:a70c0bce770d	736	// check for auto-centering every so often
mjr	5:a70c0bce770d	737	if (tCenter_.read_ms() > 1000)
mjr	5:a70c0bce770d	738	{
mjr	5:a70c0bce770d	739	// add the latest raw sample to the history list
mjr	6:cc35eb643e8f	740	AccHist *prv = p;
mjr	5:a70c0bce770d	741	iAccPrv_ = (iAccPrv_ + 1) % maxAccPrv;
mjr	6:cc35eb643e8f	742	p = accPrv_ + iAccPrv_;
mjr	6:cc35eb643e8f	743	p->set(ax, ay, prv);
mjr	5:a70c0bce770d	744
mjr	5:a70c0bce770d	745	// if we have a full complement, check for stability
mjr	5:a70c0bce770d	746	if (nAccPrv_ >= maxAccPrv)
mjr	5:a70c0bce770d	747	{
mjr	5:a70c0bce770d	748	// check if we've been stable for all recent samples
mjr	6:cc35eb643e8f	749	static const float accTol = .01;
mjr	6:cc35eb643e8f	750	AccHist *p0 = accPrv_;
mjr	6:cc35eb643e8f	751	if (p0[0].d < accTol
mjr	6:cc35eb643e8f	752	&& p0[1].d < accTol
mjr	6:cc35eb643e8f	753	&& p0[2].d < accTol
mjr	6:cc35eb643e8f	754	&& p0[3].d < accTol
mjr	6:cc35eb643e8f	755	&& p0[4].d < accTol)
mjr	5:a70c0bce770d	756	{
mjr	6:cc35eb643e8f	757	// Figure the new calibration point as the average of
mjr	6:cc35eb643e8f	758	// the samples over the rest period
mjr	6:cc35eb643e8f	759	cx_ = (p0[0].xAvg() + p0[1].xAvg() + p0[2].xAvg() + p0[3].xAvg() + p0[4].xAvg())/5.0;
mjr	6:cc35eb643e8f	760	cy_ = (p0[0].yAvg() + p0[1].yAvg() + p0[2].yAvg() + p0[3].yAvg() + p0[4].yAvg())/5.0;
mjr	5:a70c0bce770d	761	}
mjr	5:a70c0bce770d	762	}
mjr	5:a70c0bce770d	763	else
mjr	5:a70c0bce770d	764	{
mjr	5:a70c0bce770d	765	// not enough samples yet; just up the count
mjr	5:a70c0bce770d	766	++nAccPrv_;
mjr	5:a70c0bce770d	767	}
mjr	6:cc35eb643e8f	768
mjr	6:cc35eb643e8f	769	// clear the new item's running totals
mjr	6:cc35eb643e8f	770	p->clearAvg();
mjr	5:a70c0bce770d	771
mjr	5:a70c0bce770d	772	// reset the timer
mjr	5:a70c0bce770d	773	tCenter_.reset();
mjr	5:a70c0bce770d	774	}
mjr	5:a70c0bce770d	775
mjr	6:cc35eb643e8f	776	// report our integrated velocity reading in x,y
mjr	6:cc35eb643e8f	777	x = rawToReport(vx);
mjr	6:cc35eb643e8f	778	y = rawToReport(vy);
mjr	5:a70c0bce770d	779
mjr	6:cc35eb643e8f	780	#ifdef DEBUG_PRINTF
mjr	6:cc35eb643e8f	781	if (x != 0 \|\| y != 0)
mjr	6:cc35eb643e8f	782	printf("%f %f %d %d %f\r\n", vx, vy, x, y, dt);
mjr	6:cc35eb643e8f	783	#endif
mjr	3:3514575d4f86	784	}
mjr	3:3514575d4f86	785
mjr	3:3514575d4f86	786	private:
mjr	6:cc35eb643e8f	787	// adjust a raw acceleration figure to a usb report value
mjr	6:cc35eb643e8f	788	int rawToReport(float v)
mjr	5:a70c0bce770d	789	{
mjr	6:cc35eb643e8f	790	// scale to the joystick report range and round to integer
mjr	6:cc35eb643e8f	791	int i = int(round(v*JOYMAX));
mjr	5:a70c0bce770d	792
mjr	6:cc35eb643e8f	793	// if it's near the center, scale it roughly as 20*(i/20)^2,
mjr	6:cc35eb643e8f	794	// to suppress noise near the rest position
mjr	6:cc35eb643e8f	795	static const int filter[] = {
mjr	6:cc35eb643e8f	796	-18, -16, -14, -13, -11, -10, -8, -7, -6, -5, -4, -3, -2, -2, -1, -1, 0, 0, 0, 0,
mjr	6:cc35eb643e8f	797	0,
mjr	6:cc35eb643e8f	798	0, 0, 0, 0, 1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 10, 11, 13, 14, 16, 18
mjr	6:cc35eb643e8f	799	};
mjr	6:cc35eb643e8f	800	return (i > 20 \|\| i < -20 ? i : filter[i+20]);
mjr	5:a70c0bce770d	801	}
mjr	5:a70c0bce770d	802
mjr	3:3514575d4f86	803	// interrupt handler
mjr	3:3514575d4f86	804	void isr()
mjr	3:3514575d4f86	805	{
mjr	3:3514575d4f86	806	// Read the axes. Note that we have to read all three axes
mjr	3:3514575d4f86	807	// (even though we only really use x and y) in order to clear
mjr	3:3514575d4f86	808	// the "data ready" status bit in the accelerometer. The
mjr	3:3514575d4f86	809	// interrupt only occurs when the "ready" bit transitions from
mjr	3:3514575d4f86	810	// off to on, so we have to make sure it's off.
mjr	5:a70c0bce770d	811	float x, y, z;
mjr	5:a70c0bce770d	812	mma_.getAccXYZ(x, y, z);
mjr	3:3514575d4f86	813
mjr	3:3514575d4f86	814	// calculate the time since the last interrupt
mjr	3:3514575d4f86	815	float dt = tInt_.read_us()/1.0e6;
mjr	3:3514575d4f86	816	tInt_.reset();
mjr	6:cc35eb643e8f	817
mjr	6:cc35eb643e8f	818	// integrate the time slice from the previous reading to this reading
mjr	6:cc35eb643e8f	819	vx_ += (x + ax_ - 2cx_)dt/2;
mjr	6:cc35eb643e8f	820	vy_ += (y + ay_ - 2cy_)dt/2;
mjr	3:3514575d4f86	821
mjr	6:cc35eb643e8f	822	// store the updates
mjr	6:cc35eb643e8f	823	ax_ = x;
mjr	6:cc35eb643e8f	824	ay_ = y;
mjr	6:cc35eb643e8f	825	az_ = z;
mjr	3:3514575d4f86	826	}
mjr	3:3514575d4f86	827
mjr	3:3514575d4f86	828	// underlying accelerometer object
mjr	3:3514575d4f86	829	MMA8451Q mma_;
mjr	3:3514575d4f86	830
mjr	5:a70c0bce770d	831	// last raw acceleration readings
mjr	6:cc35eb643e8f	832	float ax_, ay_, az_;
mjr	5:a70c0bce770d	833
mjr	6:cc35eb643e8f	834	// integrated velocity reading since last get()
mjr	6:cc35eb643e8f	835	float vx_, vy_;
mjr	6:cc35eb643e8f	836
mjr	3:3514575d4f86	837	// timer for measuring time between get() samples
mjr	3:3514575d4f86	838	Timer tGet_;
mjr	3:3514575d4f86	839
mjr	3:3514575d4f86	840	// timer for measuring time between interrupts
mjr	3:3514575d4f86	841	Timer tInt_;
mjr	5:a70c0bce770d	842
mjr	6:cc35eb643e8f	843	// Calibration reference point for accelerometer. This is the
mjr	6:cc35eb643e8f	844	// average reading on the accelerometer when in the neutral position
mjr	6:cc35eb643e8f	845	// at rest.
mjr	6:cc35eb643e8f	846	float cx_, cy_;
mjr	5:a70c0bce770d	847
mjr	5:a70c0bce770d	848	// timer for atuo-centering
mjr	5:a70c0bce770d	849	Timer tCenter_;
mjr	6:cc35eb643e8f	850
mjr	6:cc35eb643e8f	851	// Auto-centering history. This is a separate history list that
mjr	6:cc35eb643e8f	852	// records results spaced out sparesely over time, so that we can
mjr	6:cc35eb643e8f	853	// watch for long-lasting periods of rest. When we observe nearly
mjr	6:cc35eb643e8f	854	// no motion for an extended period (on the order of 5 seconds), we
mjr	6:cc35eb643e8f	855	// take this to mean that the cabinet is at rest in its neutral
mjr	6:cc35eb643e8f	856	// position, so we take this as the calibration zero point for the
mjr	6:cc35eb643e8f	857	// accelerometer. We update this history continuously, which allows
mjr	6:cc35eb643e8f	858	// us to continuously re-calibrate the accelerometer. This ensures
mjr	6:cc35eb643e8f	859	// that we'll automatically adjust to any actual changes in the
mjr	6:cc35eb643e8f	860	// cabinet's orientation (e.g., if it gets moved slightly by an
mjr	6:cc35eb643e8f	861	// especially strong nudge) as well as any systematic drift in the
mjr	6:cc35eb643e8f	862	// accelerometer measurement bias (e.g., from temperature changes).
mjr	5:a70c0bce770d	863	int iAccPrv_, nAccPrv_;
mjr	5:a70c0bce770d	864	static const int maxAccPrv = 5;
mjr	6:cc35eb643e8f	865	AccHist accPrv_[maxAccPrv];
mjr	6:cc35eb643e8f	866
mjr	5:a70c0bce770d	867	// interurupt pin name
mjr	5:a70c0bce770d	868	PinName irqPin_;
mjr	5:a70c0bce770d	869
mjr	5:a70c0bce770d	870	// interrupt router
mjr	5:a70c0bce770d	871	InterruptIn intIn_;
mjr	3:3514575d4f86	872	};
mjr	3:3514575d4f86	873
mjr	5:a70c0bce770d	874
mjr	5:a70c0bce770d	875	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	876	//
mjr	5:a70c0bce770d	877	// Clear the I2C bus for the MMA8451!. This seems necessary some of the time
mjr	5:a70c0bce770d	878	// for reasons that aren't clear to me. Doing a hard power cycle has the same
mjr	5:a70c0bce770d	879	// effect, but when we do a soft reset, the hardware sometimes seems to leave
mjr	5:a70c0bce770d	880	// the MMA's SDA line stuck low. Forcing a series of 9 clock pulses through
mjr	5:a70c0bce770d	881	// the SCL line is supposed to clear this conidtion.
mjr	5:a70c0bce770d	882	//
mjr	5:a70c0bce770d	883	void clear_i2c()
mjr	5:a70c0bce770d	884	{
mjr	5:a70c0bce770d	885	// assume a general-purpose output pin to the I2C clock
mjr	5:a70c0bce770d	886	DigitalOut scl(MMA8451_SCL_PIN);
mjr	5:a70c0bce770d	887	DigitalIn sda(MMA8451_SDA_PIN);
mjr	5:a70c0bce770d	888
mjr	5:a70c0bce770d	889	// clock the SCL 9 times
mjr	5:a70c0bce770d	890	for (int i = 0 ; i < 9 ; ++i)
mjr	5:a70c0bce770d	891	{
mjr	5:a70c0bce770d	892	scl = 1;
mjr	5:a70c0bce770d	893	wait_us(20);
mjr	5:a70c0bce770d	894	scl = 0;
mjr	5:a70c0bce770d	895	wait_us(20);
mjr	5:a70c0bce770d	896	}
mjr	5:a70c0bce770d	897	}
mjr	5:a70c0bce770d	898
mjr	5:a70c0bce770d	899	// ---------------------------------------------------------------------------
mjr	5:a70c0bce770d	900	//
mjr	5:a70c0bce770d	901	// Main program loop. This is invoked on startup and runs forever. Our
mjr	5:a70c0bce770d	902	// main work is to read our devices (the accelerometer and the CCD), process
mjr	5:a70c0bce770d	903	// the readings into nudge and plunger position data, and send the results
mjr	5:a70c0bce770d	904	// to the host computer via the USB joystick interface. We also monitor
mjr	5:a70c0bce770d	905	// the USB connection for incoming LedWiz commands and process those into
mjr	5:a70c0bce770d	906	// port outputs.
mjr	5:a70c0bce770d	907	//
mjr	0:5acbbe3f4cf4	908	int main(void)
mjr	0:5acbbe3f4cf4	909	{
mjr	1:d913e0afb2ac	910	// turn off our on-board indicator LED
mjr	4:02c7cd7b2183	911	ledR = 1;
mjr	4:02c7cd7b2183	912	ledG = 1;
mjr	4:02c7cd7b2183	913	ledB = 1;
mjr	1:d913e0afb2ac	914
mjr	6:cc35eb643e8f	915	// initialize the LedWiz ports
mjr	6:cc35eb643e8f	916	initLwOut();
mjr	6:cc35eb643e8f	917
mjr	6:cc35eb643e8f	918	// we don't need a reset yet
mjr	6:cc35eb643e8f	919	bool needReset = false;
mjr	6:cc35eb643e8f	920
mjr	5:a70c0bce770d	921	// clear the I2C bus for the accelerometer
mjr	5:a70c0bce770d	922	clear_i2c();
mjr	5:a70c0bce770d	923
mjr	2:c174f9ee414a	924	// set up a flash memory controller
mjr	2:c174f9ee414a	925	FreescaleIAP iap;
mjr	2:c174f9ee414a	926
mjr	2:c174f9ee414a	927	// use the last sector of flash for our non-volatile memory structure
mjr	2:c174f9ee414a	928	int flash_addr = (iap.flash_size() - SECTOR_SIZE);
mjr	2:c174f9ee414a	929	NVM flash = (NVM )flash_addr;
mjr	2:c174f9ee414a	930	NVM cfg;
mjr	2:c174f9ee414a	931
mjr	2:c174f9ee414a	932	// check for valid flash
mjr	6:cc35eb643e8f	933	bool flash_valid = flash->valid();
mjr	2:c174f9ee414a	934
mjr	2:c174f9ee414a	935	// if the flash is valid, load it; otherwise initialize to defaults
mjr	2:c174f9ee414a	936	if (flash_valid) {
mjr	2:c174f9ee414a	937	memcpy(&cfg, flash, sizeof(cfg));
mjr	6:cc35eb643e8f	938	printf("Flash restored: plunger cal=%d, min=%d, zero=%d, max=%d\r\n",
mjr	6:cc35eb643e8f	939	cfg.d.plungerCal, cfg.d.plungerMin, cfg.d.plungerZero, cfg.d.plungerMax);
mjr	2:c174f9ee414a	940	}
mjr	2:c174f9ee414a	941	else {
mjr	2:c174f9ee414a	942	printf("Factory reset\r\n");
mjr	2:c174f9ee414a	943	cfg.d.sig = cfg.SIGNATURE;
mjr	2:c174f9ee414a	944	cfg.d.vsn = cfg.VERSION;
mjr	6:cc35eb643e8f	945	cfg.d.plungerCal = 0;
mjr	6:cc35eb643e8f	946	cfg.d.plungerZero = 0;
mjr	2:c174f9ee414a	947	cfg.d.plungerMin = 0;
mjr	2:c174f9ee414a	948	cfg.d.plungerMax = npix;
mjr	6:cc35eb643e8f	949	cfg.d.ledWizUnitNo = DEFAULT_LEDWIZ_UNIT_NUMBER;
mjr	6:cc35eb643e8f	950	cfg.d.ccdEnabled = true;
mjr	2:c174f9ee414a	951	}
mjr	1:d913e0afb2ac	952
mjr	6:cc35eb643e8f	953	// Create the joystick USB client. Note that we use the LedWiz unit
mjr	6:cc35eb643e8f	954	// number from the saved configuration.
mjr	6:cc35eb643e8f	955	MyUSBJoystick js(
mjr	6:cc35eb643e8f	956	USB_VENDOR_ID,
mjr	6:cc35eb643e8f	957	USB_PRODUCT_ID \| cfg.d.ledWizUnitNo,
mjr	6:cc35eb643e8f	958	USB_VERSION_NO);
mjr	6:cc35eb643e8f	959
mjr	1:d913e0afb2ac	960	// plunger calibration button debounce timer
mjr	1:d913e0afb2ac	961	Timer calBtnTimer;
mjr	1:d913e0afb2ac	962	calBtnTimer.start();
mjr	1:d913e0afb2ac	963	int calBtnLit = false;
mjr	1:d913e0afb2ac	964
mjr	1:d913e0afb2ac	965	// Calibration button state:
mjr	1:d913e0afb2ac	966	// 0 = not pushed
mjr	1:d913e0afb2ac	967	// 1 = pushed, not yet debounced
mjr	1:d913e0afb2ac	968	// 2 = pushed, debounced, waiting for hold time
mjr	1:d913e0afb2ac	969	// 3 = pushed, hold time completed - in calibration mode
mjr	1:d913e0afb2ac	970	int calBtnState = 0;
mjr	1:d913e0afb2ac	971
mjr	1:d913e0afb2ac	972	// set up a timer for our heartbeat indicator
mjr	1:d913e0afb2ac	973	Timer hbTimer;
mjr	1:d913e0afb2ac	974	hbTimer.start();
mjr	1:d913e0afb2ac	975	int hb = 0;
mjr	5:a70c0bce770d	976	uint16_t hbcnt = 0;
mjr	1:d913e0afb2ac	977
mjr	1:d913e0afb2ac	978	// set a timer for accelerometer auto-centering
mjr	1:d913e0afb2ac	979	Timer acTimer;
mjr	1:d913e0afb2ac	980	acTimer.start();
mjr	1:d913e0afb2ac	981
mjr	0:5acbbe3f4cf4	982	// create the accelerometer object
mjr	5:a70c0bce770d	983	Accel accel(MMA8451_SCL_PIN, MMA8451_SDA_PIN, MMA8451_I2C_ADDRESS, MMA8451_INT_PIN);
mjr	0:5acbbe3f4cf4	984
mjr	0:5acbbe3f4cf4	985	// create the CCD array object
mjr	1:d913e0afb2ac	986	TSL1410R ccd(PTE20, PTE21, PTB0);
mjr	2:c174f9ee414a	987
mjr	1:d913e0afb2ac	988	// last accelerometer report, in mouse coordinates
mjr	6:cc35eb643e8f	989	int x = 0, y = 0, z = 0;
mjr	6:cc35eb643e8f	990
mjr	6:cc35eb643e8f	991	// previous two plunger readings, for "debouncing" the results (z0 is
mjr	6:cc35eb643e8f	992	// the most recent, z1 is the one before that)
mjr	6:cc35eb643e8f	993	int z0 = 0, z1 = 0, z2 = 0;
mjr	6:cc35eb643e8f	994
mjr	6:cc35eb643e8f	995	// Firing in progress: we set this when we detect the start of rapid
mjr	6:cc35eb643e8f	996	// plunger movement from a retracted position towards the rest position.
mjr	6:cc35eb643e8f	997	// The actual plunger spring return speed seems to be too slow for VP,
mjr	6:cc35eb643e8f	998	// so when we detect the start of this motion, we immediately tell VP
mjr	6:cc35eb643e8f	999	// to return the plunger to rest, then we monitor the real plunger
mjr	6:cc35eb643e8f	1000	// until it atcually stops.
mjr	9:fd65b0a94720	1001	int firing = 0;
mjr	2:c174f9ee414a	1002
mjr	2:c174f9ee414a	1003	// start the first CCD integration cycle
mjr	2:c174f9ee414a	1004	ccd.clear();
mjr	9:fd65b0a94720	1005
mjr	9:fd65b0a94720	1006	// Device status. We report this on each update so that the host config
mjr	9:fd65b0a94720	1007	// tool can detect our current settings. This is a bit mask consisting
mjr	9:fd65b0a94720	1008	// of these bits:
mjr	9:fd65b0a94720	1009	// 0x01 -> plunger sensor enabled
mjr	9:fd65b0a94720	1010	uint16_t statusFlags = (cfg.d.ccdEnabled ? 0x01 : 0x00);
mjr	10:976666ffa4ef	1011
mjr	10:976666ffa4ef	1012	// flag: send a pixel dump after the next read
mjr	10:976666ffa4ef	1013	bool reportPix = false;
mjr	1:d913e0afb2ac	1014
mjr	1:d913e0afb2ac	1015	// we're all set up - now just loop, processing sensor reports and
mjr	1:d913e0afb2ac	1016	// host requests
mjr	0:5acbbe3f4cf4	1017	for (;;)
mjr	0:5acbbe3f4cf4	1018	{
mjr	0:5acbbe3f4cf4	1019	// Look for an incoming report. Continue processing input as
mjr	0:5acbbe3f4cf4	1020	// long as there's anything pending - this ensures that we
mjr	0:5acbbe3f4cf4	1021	// handle input in as timely a fashion as possible by deferring
mjr	0:5acbbe3f4cf4	1022	// output tasks as long as there's input to process.
mjr	0:5acbbe3f4cf4	1023	HID_REPORT report;
mjr	6:cc35eb643e8f	1024	while (js.readNB(&report))
mjr	0:5acbbe3f4cf4	1025	{
mjr	6:cc35eb643e8f	1026	// all Led-Wiz reports are 8 bytes exactly
mjr	6:cc35eb643e8f	1027	if (report.length == 8)
mjr	1:d913e0afb2ac	1028	{
mjr	6:cc35eb643e8f	1029	uint8_t *data = report.data;
mjr	6:cc35eb643e8f	1030	if (data[0] == 64)
mjr	0:5acbbe3f4cf4	1031	{
mjr	6:cc35eb643e8f	1032	// LWZ-SBA - first four bytes are bit-packed on/off flags
mjr	6:cc35eb643e8f	1033	// for the outputs; 5th byte is the pulse speed (0-7)
mjr	6:cc35eb643e8f	1034	//printf("LWZ-SBA %02x %02x %02x %02x ; %02x\r\n",
mjr	6:cc35eb643e8f	1035	// data[1], data[2], data[3], data[4], data[5]);
mjr	0:5acbbe3f4cf4	1036
mjr	6:cc35eb643e8f	1037	// update all on/off states
mjr	6:cc35eb643e8f	1038	for (int i = 0, bit = 1, ri = 1 ; i < 32 ; ++i, bit <<= 1)
mjr	6:cc35eb643e8f	1039	{
mjr	6:cc35eb643e8f	1040	if (bit == 0x100) {
mjr	6:cc35eb643e8f	1041	bit = 1;
mjr	6:cc35eb643e8f	1042	++ri;
mjr	6:cc35eb643e8f	1043	}
mjr	6:cc35eb643e8f	1044	wizOn[i] = ((data[ri] & bit) != 0);
mjr	6:cc35eb643e8f	1045	}
mjr	6:cc35eb643e8f	1046
mjr	6:cc35eb643e8f	1047	// update the physical outputs
mjr	1:d913e0afb2ac	1048	updateWizOuts();
mjr	6:cc35eb643e8f	1049
mjr	6:cc35eb643e8f	1050	// reset the PBA counter
mjr	6:cc35eb643e8f	1051	pbaIdx = 0;
mjr	6:cc35eb643e8f	1052	}
mjr	6:cc35eb643e8f	1053	else if (data[0] == 65)
mjr	6:cc35eb643e8f	1054	{
mjr	6:cc35eb643e8f	1055	// Private control message. This isn't an LedWiz message - it's
mjr	6:cc35eb643e8f	1056	// an extension for this device. 65 is an invalid PBA setting,
mjr	6:cc35eb643e8f	1057	// and isn't used for any other LedWiz message, so we appropriate
mjr	6:cc35eb643e8f	1058	// it for our own private use. The first byte specifies the
mjr	6:cc35eb643e8f	1059	// message type.
mjr	6:cc35eb643e8f	1060	if (data[1] == 1)
mjr	6:cc35eb643e8f	1061	{
mjr	9:fd65b0a94720	1062	// 1 = Set Configuration:
mjr	6:cc35eb643e8f	1063	// data[2] = LedWiz unit number (0x00 to 0x0f)
mjr	6:cc35eb643e8f	1064	// data[3] = feature enable bit mask:
mjr	6:cc35eb643e8f	1065	// 0x01 = enable CCD
mjr	6:cc35eb643e8f	1066
mjr	6:cc35eb643e8f	1067	// we'll need a reset if the LedWiz unit number is changing
mjr	6:cc35eb643e8f	1068	uint8_t newUnitNo = data[2] & 0x0f;
mjr	6:cc35eb643e8f	1069	needReset \|= (newUnitNo != cfg.d.ledWizUnitNo);
mjr	6:cc35eb643e8f	1070
mjr	6:cc35eb643e8f	1071	// set the configuration parameters from the message
mjr	6:cc35eb643e8f	1072	cfg.d.ledWizUnitNo = newUnitNo;
mjr	6:cc35eb643e8f	1073	cfg.d.ccdEnabled = data[3] & 0x01;
mjr	6:cc35eb643e8f	1074
mjr	9:fd65b0a94720	1075	// update the status flags
mjr	9:fd65b0a94720	1076	statusFlags = (statusFlags & ~0x01) \| (data[3] & 0x01);
mjr	9:fd65b0a94720	1077
mjr	9:fd65b0a94720	1078	// if the ccd is no longer enabled, use 0 for z reports
mjr	9:fd65b0a94720	1079	if (!cfg.d.ccdEnabled)
mjr	9:fd65b0a94720	1080	z = 0;
mjr	9:fd65b0a94720	1081
mjr	6:cc35eb643e8f	1082	// save the configuration
mjr	6:cc35eb643e8f	1083	cfg.save(iap, flash_addr);
mjr	6:cc35eb643e8f	1084	}
mjr	9:fd65b0a94720	1085	else if (data[1] == 2)
mjr	9:fd65b0a94720	1086	{
mjr	9:fd65b0a94720	1087	// 2 = Calibrate plunger
mjr	9:fd65b0a94720	1088	// (No parameters)
mjr	9:fd65b0a94720	1089
mjr	9:fd65b0a94720	1090	// enter calibration mode
mjr	9:fd65b0a94720	1091	calBtnState = 3;
mjr	9:fd65b0a94720	1092	calBtnTimer.reset();
mjr	9:fd65b0a94720	1093	cfg.resetPlunger();
mjr	9:fd65b0a94720	1094	}
mjr	10:976666ffa4ef	1095	else if (data[1] == 3)
mjr	10:976666ffa4ef	1096	{
mjr	10:976666ffa4ef	1097	// 3 = pixel dump
mjr	10:976666ffa4ef	1098	// (No parameters)
mjr	10:976666ffa4ef	1099	reportPix = true;
mjr	10:976666ffa4ef	1100
mjr	10:976666ffa4ef	1101	// show purple until we finish sending the report
mjr	10:976666ffa4ef	1102	ledR = 0;
mjr	10:976666ffa4ef	1103	ledB = 0;
mjr	10:976666ffa4ef	1104	ledG = 1;
mjr	10:976666ffa4ef	1105	}
mjr	6:cc35eb643e8f	1106	}
mjr	6:cc35eb643e8f	1107	else
mjr	6:cc35eb643e8f	1108	{
mjr	6:cc35eb643e8f	1109	// LWZ-PBA - full state dump; each byte is one output
mjr	6:cc35eb643e8f	1110	// in the current bank. pbaIdx keeps track of the bank;
mjr	6:cc35eb643e8f	1111	// this is incremented implicitly by each PBA message.
mjr	6:cc35eb643e8f	1112	//printf("LWZ-PBA[%d] %02x %02x %02x %02x %02x %02x %02x %02x\r\n",
mjr	6:cc35eb643e8f	1113	// pbaIdx, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
mjr	6:cc35eb643e8f	1114
mjr	6:cc35eb643e8f	1115	// update all output profile settings
mjr	6:cc35eb643e8f	1116	for (int i = 0 ; i < 8 ; ++i)
mjr	6:cc35eb643e8f	1117	wizVal[pbaIdx + i] = data[i];
mjr	6:cc35eb643e8f	1118
mjr	6:cc35eb643e8f	1119	// update the physical LED state if this is the last bank
mjr	6:cc35eb643e8f	1120	if (pbaIdx == 24)
mjr	6:cc35eb643e8f	1121	updateWizOuts();
mjr	6:cc35eb643e8f	1122
mjr	6:cc35eb643e8f	1123	// advance to the next bank
mjr	6:cc35eb643e8f	1124	pbaIdx = (pbaIdx + 8) & 31;
mjr	6:cc35eb643e8f	1125	}
mjr	0:5acbbe3f4cf4	1126	}
mjr	0:5acbbe3f4cf4	1127	}
mjr	1:d913e0afb2ac	1128
mjr	1:d913e0afb2ac	1129	// check for plunger calibration
mjr	1:d913e0afb2ac	1130	if (!calBtn)
mjr	0:5acbbe3f4cf4	1131	{
mjr	1:d913e0afb2ac	1132	// check the state
mjr	1:d913e0afb2ac	1133	switch (calBtnState)
mjr	0:5acbbe3f4cf4	1134	{
mjr	1:d913e0afb2ac	1135	case 0:
mjr	1:d913e0afb2ac	1136	// button not yet pushed - start debouncing
mjr	1:d913e0afb2ac	1137	calBtnTimer.reset();
mjr	1:d913e0afb2ac	1138	calBtnState = 1;
mjr	1:d913e0afb2ac	1139	break;
mjr	1:d913e0afb2ac	1140
mjr	1:d913e0afb2ac	1141	case 1:
mjr	1:d913e0afb2ac	1142	// pushed, not yet debounced - if the debounce time has
mjr	1:d913e0afb2ac	1143	// passed, start the hold period
mjr	9:fd65b0a94720	1144	if (calBtnTimer.read_ms() > 50)
mjr	1:d913e0afb2ac	1145	calBtnState = 2;
mjr	1:d913e0afb2ac	1146	break;
mjr	1:d913e0afb2ac	1147
mjr	1:d913e0afb2ac	1148	case 2:
mjr	1:d913e0afb2ac	1149	// in the hold period - if the button has been held down
mjr	1:d913e0afb2ac	1150	// for the entire hold period, move to calibration mode
mjr	9:fd65b0a94720	1151	if (calBtnTimer.read_ms() > 2050)
mjr	1:d913e0afb2ac	1152	{
mjr	1:d913e0afb2ac	1153	// enter calibration mode
mjr	1:d913e0afb2ac	1154	calBtnState = 3;
mjr	9:fd65b0a94720	1155	calBtnTimer.reset();
mjr	9:fd65b0a94720	1156	cfg.resetPlunger();
mjr	1:d913e0afb2ac	1157	}
mjr	1:d913e0afb2ac	1158	break;
mjr	2:c174f9ee414a	1159
mjr	2:c174f9ee414a	1160	case 3:
mjr	9:fd65b0a94720	1161	// Already in calibration mode - pushing the button here
mjr	9:fd65b0a94720	1162	// doesn't change the current state, but we won't leave this
mjr	9:fd65b0a94720	1163	// state as long as it's held down. So nothing changes here.
mjr	2:c174f9ee414a	1164	break;
mjr	0:5acbbe3f4cf4	1165	}
mjr	0:5acbbe3f4cf4	1166	}
mjr	1:d913e0afb2ac	1167	else
mjr	1:d913e0afb2ac	1168	{
mjr	2:c174f9ee414a	1169	// Button released. If we're in calibration mode, and
mjr	2:c174f9ee414a	1170	// the calibration time has elapsed, end the calibration
mjr	2:c174f9ee414a	1171	// and save the results to flash.
mjr	2:c174f9ee414a	1172	//
mjr	2:c174f9ee414a	1173	// Otherwise, return to the base state without saving anything.
mjr	2:c174f9ee414a	1174	// If the button is released before we make it to calibration
mjr	2:c174f9ee414a	1175	// mode, it simply cancels the attempt.
mjr	9:fd65b0a94720	1176	if (calBtnState == 3 && calBtnTimer.read_ms() > 15000)
mjr	2:c174f9ee414a	1177	{
mjr	2:c174f9ee414a	1178	// exit calibration mode
mjr	1:d913e0afb2ac	1179	calBtnState = 0;
mjr	2:c174f9ee414a	1180
mjr	6:cc35eb643e8f	1181	// save the updated configuration
mjr	6:cc35eb643e8f	1182	cfg.d.plungerCal = 1;
mjr	6:cc35eb643e8f	1183	cfg.save(iap, flash_addr);
mjr	2:c174f9ee414a	1184
mjr	2:c174f9ee414a	1185	// the flash state is now valid
mjr	2:c174f9ee414a	1186	flash_valid = true;
mjr	2:c174f9ee414a	1187	}
mjr	2:c174f9ee414a	1188	else if (calBtnState != 3)
mjr	2:c174f9ee414a	1189	{
mjr	2:c174f9ee414a	1190	// didn't make it to calibration mode - cancel the operation
mjr	1:d913e0afb2ac	1191	calBtnState = 0;
mjr	2:c174f9ee414a	1192	}
mjr	1:d913e0afb2ac	1193	}
mjr	1:d913e0afb2ac	1194
mjr	1:d913e0afb2ac	1195	// light/flash the calibration button light, if applicable
mjr	1:d913e0afb2ac	1196	int newCalBtnLit = calBtnLit;
mjr	1:d913e0afb2ac	1197	switch (calBtnState)
mjr	0:5acbbe3f4cf4	1198	{
mjr	1:d913e0afb2ac	1199	case 2:
mjr	1:d913e0afb2ac	1200	// in the hold period - flash the light
mjr	9:fd65b0a94720	1201	newCalBtnLit = ((calBtnTimer.read_ms()/250) & 1);
mjr	1:d913e0afb2ac	1202	break;
mjr	1:d913e0afb2ac	1203
mjr	1:d913e0afb2ac	1204	case 3:
mjr	1:d913e0afb2ac	1205	// calibration mode - show steady on
mjr	1:d913e0afb2ac	1206	newCalBtnLit = true;
mjr	1:d913e0afb2ac	1207	break;
mjr	1:d913e0afb2ac	1208
mjr	1:d913e0afb2ac	1209	default:
mjr	1:d913e0afb2ac	1210	// not calibrating/holding - show steady off
mjr	1:d913e0afb2ac	1211	newCalBtnLit = false;
mjr	1:d913e0afb2ac	1212	break;
mjr	1:d913e0afb2ac	1213	}
mjr	3:3514575d4f86	1214
mjr	3:3514575d4f86	1215	// light or flash the external calibration button LED, and
mjr	3:3514575d4f86	1216	// do the same with the on-board blue LED
mjr	1:d913e0afb2ac	1217	if (calBtnLit != newCalBtnLit)
mjr	1:d913e0afb2ac	1218	{
mjr	1:d913e0afb2ac	1219	calBtnLit = newCalBtnLit;
mjr	2:c174f9ee414a	1220	if (calBtnLit) {
mjr	2:c174f9ee414a	1221	calBtnLed = 1;
mjr	4:02c7cd7b2183	1222	ledR = 1;
mjr	4:02c7cd7b2183	1223	ledG = 1;
mjr	9:fd65b0a94720	1224	ledB = 0;
mjr	2:c174f9ee414a	1225	}
mjr	2:c174f9ee414a	1226	else {
mjr	2:c174f9ee414a	1227	calBtnLed = 0;
mjr	4:02c7cd7b2183	1228	ledR = 1;
mjr	4:02c7cd7b2183	1229	ledG = 1;
mjr	9:fd65b0a94720	1230	ledB = 1;
mjr	2:c174f9ee414a	1231	}
mjr	1:d913e0afb2ac	1232	}
mjr	1:d913e0afb2ac	1233
mjr	6:cc35eb643e8f	1234	// read the plunger sensor, if it's enabled
mjr	10:976666ffa4ef	1235	uint16_t pix[npix];
mjr	6:cc35eb643e8f	1236	if (cfg.d.ccdEnabled)
mjr	6:cc35eb643e8f	1237	{
mjr	6:cc35eb643e8f	1238	// start with the previous reading, in case we don't have a
mjr	6:cc35eb643e8f	1239	// clear result on this frame
mjr	6:cc35eb643e8f	1240	int znew = z;
mjr	2:c174f9ee414a	1241
mjr	6:cc35eb643e8f	1242	// read the array
mjr	6:cc35eb643e8f	1243	ccd.read(pix, npix);
mjr	6:cc35eb643e8f	1244
mjr	6:cc35eb643e8f	1245	// get the average brightness at each end of the sensor
mjr	6:cc35eb643e8f	1246	long avg1 = (long(pix[0]) + long(pix[1]) + long(pix[2]) + long(pix[3]) + long(pix[4]))/5;
mjr	6:cc35eb643e8f	1247	long avg2 = (long(pix[npix-1]) + long(pix[npix-2]) + long(pix[npix-3]) + long(pix[npix-4]) + long(pix[npix-5]))/5;
mjr	6:cc35eb643e8f	1248
mjr	6:cc35eb643e8f	1249	// figure the midpoint in the brightness; multiply by 3 so that we can
mjr	6:cc35eb643e8f	1250	// compare sums of three pixels at a time to smooth out noise
mjr	6:cc35eb643e8f	1251	long midpt = (avg1 + avg2)/2 * 3;
mjr	6:cc35eb643e8f	1252
mjr	6:cc35eb643e8f	1253	// Work from the bright end to the dark end. VP interprets the
mjr	6:cc35eb643e8f	1254	// Z axis value as the amount the plunger is pulled: zero is the
mjr	6:cc35eb643e8f	1255	// rest position, and the axis maximum is fully pulled. So we
mjr	6:cc35eb643e8f	1256	// essentially want to report how much of the sensor is lit,
mjr	6:cc35eb643e8f	1257	// since this increases as the plunger is pulled back.
mjr	6:cc35eb643e8f	1258	int si = 1, di = 1;
mjr	6:cc35eb643e8f	1259	if (avg1 < avg2)
mjr	6:cc35eb643e8f	1260	si = npix - 2, di = -1;
mjr	6:cc35eb643e8f	1261
mjr	6:cc35eb643e8f	1262	// If the bright end and dark end don't differ by enough, skip this
mjr	6:cc35eb643e8f	1263	// reading entirely - we must have an overexposed or underexposed frame.
mjr	6:cc35eb643e8f	1264	// Otherwise proceed with the scan.
mjr	6:cc35eb643e8f	1265	if (labs(avg1 - avg2) > 0x1000)
mjr	6:cc35eb643e8f	1266	{
mjr	6:cc35eb643e8f	1267	uint16_t *pixp = pix + si;
mjr	6:cc35eb643e8f	1268	for (int n = 1 ; n < npix - 1 ; ++n, pixp += di)
mjr	6:cc35eb643e8f	1269	{
mjr	6:cc35eb643e8f	1270	// if we've crossed the midpoint, report this position
mjr	6:cc35eb643e8f	1271	if (long(pixp[-1]) + long(pixp[0]) + long(pixp[1]) < midpt)
mjr	6:cc35eb643e8f	1272	{
mjr	6:cc35eb643e8f	1273	// note the new position
mjr	6:cc35eb643e8f	1274	int pos = n;
mjr	6:cc35eb643e8f	1275
mjr	6:cc35eb643e8f	1276	// Calibrate, or apply calibration, depending on the mode.
mjr	6:cc35eb643e8f	1277	// In either case, normalize to our range. VP appears to
mjr	6:cc35eb643e8f	1278	// ignore negative Z axis values.
mjr	6:cc35eb643e8f	1279	if (calBtnState == 3)
mjr	6:cc35eb643e8f	1280	{
mjr	6:cc35eb643e8f	1281	// calibrating - note if we're expanding the calibration envelope
mjr	6:cc35eb643e8f	1282	if (pos < cfg.d.plungerMin)
mjr	6:cc35eb643e8f	1283	cfg.d.plungerMin = pos;
mjr	6:cc35eb643e8f	1284	if (pos < cfg.d.plungerZero)
mjr	6:cc35eb643e8f	1285	cfg.d.plungerZero = pos;
mjr	6:cc35eb643e8f	1286	if (pos > cfg.d.plungerMax)
mjr	6:cc35eb643e8f	1287	cfg.d.plungerMax = pos;
mjr	6:cc35eb643e8f	1288
mjr	6:cc35eb643e8f	1289	// normalize to the full physical range while calibrating
mjr	6:cc35eb643e8f	1290	znew = int(round(float(pos)/npix * JOYMAX));
mjr	6:cc35eb643e8f	1291	}
mjr	6:cc35eb643e8f	1292	else
mjr	6:cc35eb643e8f	1293	{
mjr	6:cc35eb643e8f	1294	// Running normally - normalize to the calibration range. Note
mjr	6:cc35eb643e8f	1295	// that values below the zero point are allowed - the zero point
mjr	6:cc35eb643e8f	1296	// represents the park position, where the plunger sits when at
mjr	6:cc35eb643e8f	1297	// rest, but a mechanical plunger has a smmall amount of travel
mjr	6:cc35eb643e8f	1298	// in the "push" direction. We represent forward travel with
mjr	6:cc35eb643e8f	1299	// negative z values.
mjr	6:cc35eb643e8f	1300	if (pos > cfg.d.plungerMax)
mjr	6:cc35eb643e8f	1301	pos = cfg.d.plungerMax;
mjr	6:cc35eb643e8f	1302	znew = int(round(float(pos - cfg.d.plungerZero)
mjr	6:cc35eb643e8f	1303	/ (cfg.d.plungerMax - cfg.d.plungerZero + 1) * JOYMAX));
mjr	6:cc35eb643e8f	1304	}
mjr	6:cc35eb643e8f	1305
mjr	6:cc35eb643e8f	1306	// done
mjr	6:cc35eb643e8f	1307	break;
mjr	6:cc35eb643e8f	1308	}
mjr	6:cc35eb643e8f	1309	}
mjr	6:cc35eb643e8f	1310	}
mjr	7:100a25f8bf56	1311
mjr	7:100a25f8bf56	1312	// Determine if the plunger is being fired - i.e., if the player
mjr	7:100a25f8bf56	1313	// has just released the plunger from a retracted position.
mjr	6:cc35eb643e8f	1314	//
mjr	7:100a25f8bf56	1315	// We treat firing as an event. That is, we tell VP when the
mjr	7:100a25f8bf56	1316	// plunger is fired, and then stop sending data until the firing
mjr	7:100a25f8bf56	1317	// is complete, allowing VP to carry out the firing motion using
mjr	7:100a25f8bf56	1318	// its internal model plunger rather than trying to track the
mjr	7:100a25f8bf56	1319	// intermediate positions of the mechanical plunger throughout
mjr	9:fd65b0a94720	1320	// the firing motion. This is essential because the firing
mjr	9:fd65b0a94720	1321	// motion is too fast for us to track - in the time it takes us
mjr	9:fd65b0a94720	1322	// to read one frame, the plunger can make it all the way to the
mjr	9:fd65b0a94720	1323	// zero position and bounce back halfway. Fortunately, the range
mjr	9:fd65b0a94720	1324	// of motions for the plunger is limited, so if we see any rapid
mjr	9:fd65b0a94720	1325	// change of position toward the rest position, it's reasonably
mjr	9:fd65b0a94720	1326	// safe to interpret it as a firing event.
mjr	9:fd65b0a94720	1327	//
mjr	9:fd65b0a94720	1328	// This isn't foolproof. The user can trick us by doing a
mjr	9:fd65b0a94720	1329	// controlled rapid forward push but stopping short of the rest
mjr	9:fd65b0a94720	1330	// position. We'll misinterpret that as a firing event. But
mjr	9:fd65b0a94720	1331	// that's not a natural motion that a user would make with a
mjr	9:fd65b0a94720	1332	// plunger, so it's probably an acceptable false positive.
mjr	9:fd65b0a94720	1333	//
mjr	9:fd65b0a94720	1334	// Possible future enhancement: we could add a second physical
mjr	9:fd65b0a94720	1335	// sensor that detects when the plunger reaches the zero position
mjr	9:fd65b0a94720	1336	// and asserts an interrupt. In the interrupt handler, set a
mjr	9:fd65b0a94720	1337	// flag indicating the zero position signal. On each scan of
mjr	9:fd65b0a94720	1338	// the CCD, also check that flag; if it's set, enter firing
mjr	9:fd65b0a94720	1339	// event mode just as we do now. The key here is that the
mjr	9:fd65b0a94720	1340	// secondary sensor would have to be something much faster
mjr	9:fd65b0a94720	1341	// than our CCD scan - it would have to react on, say, the
mjr	9:fd65b0a94720	1342	// millisecond time scale. A simple mechanical switch or a
mjr	9:fd65b0a94720	1343	// proximity sensor could work. This would let us detect
mjr	9:fd65b0a94720	1344	// with certainty when the plunger physically fires, eliminating
mjr	9:fd65b0a94720	1345	// the case where the use can fool us with motion that's fast
mjr	9:fd65b0a94720	1346	// enough to look like a release but doesn't actually reach the
mjr	9:fd65b0a94720	1347	// starting position.
mjr	6:cc35eb643e8f	1348	//
mjr	7:100a25f8bf56	1349	// To detremine when a firing even occurs, we watch for rapid
mjr	7:100a25f8bf56	1350	// motion from a retracted position towards the rest position -
mjr	7:100a25f8bf56	1351	// that is, large position changes in the negative direction over
mjr	7:100a25f8bf56	1352	// a couple of consecutive readings. When we see a rapid move
mjr	7:100a25f8bf56	1353	// toward zero, we set our internal 'firing' flag, immediately
mjr	7:100a25f8bf56	1354	// report to VP that the plunger has returned to the zero
mjr	7:100a25f8bf56	1355	// position, and then suspend reports until the mechanical
mjr	7:100a25f8bf56	1356	// readings indicate that the plunger has come to rest (indicated
mjr	7:100a25f8bf56	1357	// by several readings in a row at roughly the same position).
mjr	9:fd65b0a94720	1358	//
mjr	9:fd65b0a94720	1359	// Tolerance for firing is 1/3 of the current pull distance, or
mjr	9:fd65b0a94720	1360	// about 1/2", whichever is greater. Making this value too small
mjr	9:fd65b0a94720	1361	// makes for too many false positives. Empirically, 1/4" is too
mjr	9:fd65b0a94720	1362	// twitchy, so set a floor at about 1/2". But we can be less
mjr	9:fd65b0a94720	1363	// sensitive the further back the plunger is pulled, since even
mjr	9:fd65b0a94720	1364	// a long pull will snap back quickly. Note that JOYMAX always
mjr	9:fd65b0a94720	1365	// corresponds to about 3", no matter how many pixels we're
mjr	9:fd65b0a94720	1366	// reading, since the physical sensor is about 3" long; so we
mjr	9:fd65b0a94720	1367	// factor out the pixel count calculate (approximate) physical
mjr	9:fd65b0a94720	1368	// distances based on the normalized axis range.
mjr	9:fd65b0a94720	1369	//
mjr	9:fd65b0a94720	1370	// Firing pattern: when firing, don't simply report a solid 0,
mjr	9:fd65b0a94720	1371	// but instead report a series of pseudo-bouces. This looks
mjr	9:fd65b0a94720	1372	// more realistic, beacause the real plunger is also bouncing
mjr	9:fd65b0a94720	1373	// around during this time. To get maximum firing power in
mjr	9:fd65b0a94720	1374	// the simulation, though, our pseudo-bounces are tiny cmopared
mjr	9:fd65b0a94720	1375	// to the real thing.
mjr	9:fd65b0a94720	1376	const int restTol = JOYMAX/24;
mjr	9:fd65b0a94720	1377	int fireTol = z/3 > JOYMAX/6 ? z/3 : JOYMAX/6;
mjr	9:fd65b0a94720	1378	static const int firePattern[] = {
mjr	9:fd65b0a94720	1379	-JOYMAX/12, -JOYMAX/12, -JOYMAX/12,
mjr	9:fd65b0a94720	1380	};
mjr	9:fd65b0a94720	1381	if (firing != 0)
mjr	6:cc35eb643e8f	1382	{
mjr	6:cc35eb643e8f	1383	// Firing in progress - we've already told VP to send its
mjr	6:cc35eb643e8f	1384	// model plunger all the way back to the rest position, so
mjr	6:cc35eb643e8f	1385	// send no further reports until the mechanical plunger
mjr	6:cc35eb643e8f	1386	// actually comes to rest somewhere.
mjr	6:cc35eb643e8f	1387	if (abs(z0 - z2) < restTol && abs(znew - z2) < restTol)
mjr	6:cc35eb643e8f	1388	{
mjr	6:cc35eb643e8f	1389	// the plunger is back at rest - firing is done
mjr	9:fd65b0a94720	1390	firing = 0;
mjr	6:cc35eb643e8f	1391
mjr	6:cc35eb643e8f	1392	// resume normal reporting
mjr	6:cc35eb643e8f	1393	z = z2;
mjr	6:cc35eb643e8f	1394	}
mjr	9:fd65b0a94720	1395	else if (firing < countof(firePattern))
mjr	9:fd65b0a94720	1396	{
mjr	9:fd65b0a94720	1397	// firing - report the next position in the pseudo-bounce
mjr	9:fd65b0a94720	1398	// pattern
mjr	9:fd65b0a94720	1399	z = firePattern[firing++];
mjr	9:fd65b0a94720	1400	}
mjr	9:fd65b0a94720	1401	else
mjr	9:fd65b0a94720	1402	{
mjr	9:fd65b0a94720	1403	// firing, out of pseudo-bounce items - just report the
mjr	9:fd65b0a94720	1404	// rest position
mjr	9:fd65b0a94720	1405	z = 0;
mjr	9:fd65b0a94720	1406	}
mjr	6:cc35eb643e8f	1407	}
mjr	6:cc35eb643e8f	1408	else if (z0 < z2 && z1 < z2 && znew < z2
mjr	6:cc35eb643e8f	1409	&& (z0 < z2 - fireTol
mjr	6:cc35eb643e8f	1410	\|\| z1 < z2 - fireTol
mjr	6:cc35eb643e8f	1411	\|\| znew < z2 - fireTol))
mjr	6:cc35eb643e8f	1412	{
mjr	6:cc35eb643e8f	1413	// Big jumps toward rest position in last two readings -
mjr	6:cc35eb643e8f	1414	// firing has begun. Report an immediate return to the
mjr	6:cc35eb643e8f	1415	// rest position, and send no further reports until the
mjr	6:cc35eb643e8f	1416	// physical plunger has come to rest. This effectively
mjr	6:cc35eb643e8f	1417	// detaches VP's model plunger from the real world for
mjr	6:cc35eb643e8f	1418	// the duration of the spring return, letting VP evolve
mjr	6:cc35eb643e8f	1419	// its model without trying to synchronize with the
mjr	6:cc35eb643e8f	1420	// mechanical version. The release motion is too fast
mjr	6:cc35eb643e8f	1421	// for that to work well; we can't take samples quickly
mjr	6:cc35eb643e8f	1422	// enough to get prcise velocity or acceleration
mjr	6:cc35eb643e8f	1423	// readings. It's better to let VP figure the speed
mjr	6:cc35eb643e8f	1424	// and acceleration through modeling. Plus, that lets
mjr	6:cc35eb643e8f	1425	// each virtual table set the desired parameters for its
mjr	6:cc35eb643e8f	1426	// virtual plunger, rather than imposing the actual
mjr	6:cc35eb643e8f	1427	// mechanical charateristics of the physical plunger on
mjr	6:cc35eb643e8f	1428	// every table.
mjr	9:fd65b0a94720	1429	firing = 1;
mjr	9:fd65b0a94720	1430
mjr	9:fd65b0a94720	1431	// report the first firing pattern position
mjr	9:fd65b0a94720	1432	z = firePattern[0];
mjr	6:cc35eb643e8f	1433	}
mjr	6:cc35eb643e8f	1434	else
mjr	6:cc35eb643e8f	1435	{
mjr	6:cc35eb643e8f	1436	// everything normal; report the 3rd recent position on
mjr	6:cc35eb643e8f	1437	// tape delay
mjr	6:cc35eb643e8f	1438	z = z2;
mjr	6:cc35eb643e8f	1439	}
mjr	6:cc35eb643e8f	1440
mjr	6:cc35eb643e8f	1441	// shift in the new reading
mjr	6:cc35eb643e8f	1442	z2 = z1;
mjr	6:cc35eb643e8f	1443	z1 = z0;
mjr	6:cc35eb643e8f	1444	z0 = znew;
mjr	2:c174f9ee414a	1445	}
mjr	9:fd65b0a94720	1446	else
mjr	9:fd65b0a94720	1447	{
mjr	9:fd65b0a94720	1448	// plunger disabled - pause 10ms to throttle updates to a
mjr	9:fd65b0a94720	1449	// reasonable pace
mjr	9:fd65b0a94720	1450	wait_ms(10);
mjr	9:fd65b0a94720	1451	}
mjr	6:cc35eb643e8f	1452
mjr	1:d913e0afb2ac	1453	// read the accelerometer
mjr	9:fd65b0a94720	1454	int xa, ya;
mjr	9:fd65b0a94720	1455	accel.get(xa, ya);
mjr	1:d913e0afb2ac	1456
mjr	6:cc35eb643e8f	1457	// confine the results to our joystick axis range
mjr	6:cc35eb643e8f	1458	if (xa < -JOYMAX) xa = -JOYMAX;
mjr	6:cc35eb643e8f	1459	if (xa > JOYMAX) xa = JOYMAX;
mjr	6:cc35eb643e8f	1460	if (ya < -JOYMAX) ya = -JOYMAX;
mjr	6:cc35eb643e8f	1461	if (ya > JOYMAX) ya = JOYMAX;
mjr	1:d913e0afb2ac	1462
mjr	6:cc35eb643e8f	1463	// store the updated accelerometer coordinates
mjr	6:cc35eb643e8f	1464	x = xa;
mjr	6:cc35eb643e8f	1465	y = ya;
mjr	6:cc35eb643e8f	1466
mjr	8:c732e279ee29	1467	// Send the status report. Note that the nominal x and y axes
mjr	8:c732e279ee29	1468	// are reversed - this makes it more intuitive to set up in VP.
mjr	8:c732e279ee29	1469	// If we mount the Freesale card flat on the floor of the cabinet
mjr	8:c732e279ee29	1470	// with the USB connectors facing the front of the cabinet, this
mjr	8:c732e279ee29	1471	// arrangement of our nominal axes aligns with VP's standard
mjr	8:c732e279ee29	1472	// setting, so that we can configure VP with X Axis = X on the
mjr	8:c732e279ee29	1473	// joystick and Y Axis = Y on the joystick.
mjr	9:fd65b0a94720	1474	js.update(y, x, z, 0, statusFlags);
mjr	1:d913e0afb2ac	1475
mjr	10:976666ffa4ef	1476	// If we're in pixel dump mode, report all pixel exposure values
mjr	10:976666ffa4ef	1477	if (reportPix)
mjr	10:976666ffa4ef	1478	{
mjr	10:976666ffa4ef	1479	// we have satisfied this request
mjr	10:976666ffa4ef	1480	reportPix = false;
mjr	10:976666ffa4ef	1481
mjr	10:976666ffa4ef	1482	// send reports for all pixels
mjr	10:976666ffa4ef	1483	int idx = 0;
mjr	10:976666ffa4ef	1484	while (idx < npix)
mjr	10:976666ffa4ef	1485	js.updateExposure(idx, npix, pix);
mjr	10:976666ffa4ef	1486
mjr	10:976666ffa4ef	1487	// The pixel dump requires many USB reports, since each report
mjr	10:976666ffa4ef	1488	// can only send a few pixel values. An integration cycle has
mjr	10:976666ffa4ef	1489	// been running all this time, since each read starts a new
mjr	10:976666ffa4ef	1490	// cycle. Our timing is longer than usual on this round, so
mjr	10:976666ffa4ef	1491	// the integration won't be comparable to a normal cycle. Throw
mjr	10:976666ffa4ef	1492	// this one away by doing a read now, and throwing it away - that
mjr	10:976666ffa4ef	1493	// will get the timing of the next cycle roughly back to normal.
mjr	10:976666ffa4ef	1494	ccd.read(pix, npix);
mjr	10:976666ffa4ef	1495	}
mjr	10:976666ffa4ef	1496
mjr	6:cc35eb643e8f	1497	#ifdef DEBUG_PRINTF
mjr	6:cc35eb643e8f	1498	if (x != 0 \|\| y != 0)
mjr	6:cc35eb643e8f	1499	printf("%d,%d\r\n", x, y);
mjr	6:cc35eb643e8f	1500	#endif
mjr	6:cc35eb643e8f	1501
mjr	6:cc35eb643e8f	1502	// provide a visual status indication on the on-board LED
mjr	5:a70c0bce770d	1503	if (calBtnState < 2 && hbTimer.read_ms() > 1000)
mjr	1:d913e0afb2ac	1504	{
mjr	5:a70c0bce770d	1505	if (js.isSuspended() \|\| !js.isConnected())
mjr	2:c174f9ee414a	1506	{
mjr	5:a70c0bce770d	1507	// suspended - turn off the LED
mjr	4:02c7cd7b2183	1508	ledR = 1;
mjr	4:02c7cd7b2183	1509	ledG = 1;
mjr	4:02c7cd7b2183	1510	ledB = 1;
mjr	5:a70c0bce770d	1511
mjr	5:a70c0bce770d	1512	// show a status flash every so often
mjr	5:a70c0bce770d	1513	if (hbcnt % 3 == 0)
mjr	5:a70c0bce770d	1514	{
mjr	6:cc35eb643e8f	1515	// disconnected = red/red flash; suspended = red
mjr	5:a70c0bce770d	1516	for (int n = js.isConnected() ? 1 : 2 ; n > 0 ; --n)
mjr	5:a70c0bce770d	1517	{
mjr	5:a70c0bce770d	1518	ledR = 0;
mjr	5:a70c0bce770d	1519	wait(0.05);
mjr	5:a70c0bce770d	1520	ledR = 1;
mjr	5:a70c0bce770d	1521	wait(0.25);
mjr	5:a70c0bce770d	1522	}
mjr	5:a70c0bce770d	1523	}
mjr	2:c174f9ee414a	1524	}
mjr	6:cc35eb643e8f	1525	else if (needReset)
mjr	2:c174f9ee414a	1526	{
mjr	6:cc35eb643e8f	1527	// connected, need to reset due to changes in config parameters -
mjr	6:cc35eb643e8f	1528	// flash red/green
mjr	6:cc35eb643e8f	1529	hb = !hb;
mjr	6:cc35eb643e8f	1530	ledR = (hb ? 0 : 1);
mjr	6:cc35eb643e8f	1531	ledG = (hb ? 1 : 0);
mjr	6:cc35eb643e8f	1532	ledB = 0;
mjr	6:cc35eb643e8f	1533	}
mjr	6:cc35eb643e8f	1534	else if (cfg.d.ccdEnabled && !cfg.d.plungerCal)
mjr	6:cc35eb643e8f	1535	{
mjr	6:cc35eb643e8f	1536	// connected, plunger calibration needed - flash yellow/green
mjr	6:cc35eb643e8f	1537	hb = !hb;
mjr	6:cc35eb643e8f	1538	ledR = (hb ? 0 : 1);
mjr	6:cc35eb643e8f	1539	ledG = 0;
mjr	6:cc35eb643e8f	1540	ledB = 1;
mjr	6:cc35eb643e8f	1541	}
mjr	6:cc35eb643e8f	1542	else
mjr	6:cc35eb643e8f	1543	{
mjr	6:cc35eb643e8f	1544	// connected - flash blue/green
mjr	2:c174f9ee414a	1545	hb = !hb;
mjr	4:02c7cd7b2183	1546	ledR = 1;
mjr	4:02c7cd7b2183	1547	ledG = (hb ? 0 : 1);
mjr	4:02c7cd7b2183	1548	ledB = (hb ? 1 : 0);
mjr	2:c174f9ee414a	1549	}
mjr	1:d913e0afb2ac	1550
mjr	1:d913e0afb2ac	1551	// reset the heartbeat timer
mjr	1:d913e0afb2ac	1552	hbTimer.reset();
mjr	5:a70c0bce770d	1553	++hbcnt;
mjr	1:d913e0afb2ac	1554	}
mjr	1:d913e0afb2ac	1555	}
mjr	0:5acbbe3f4cf4	1556	}

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	11 Sep 2015
Imports:	2
Forks:	0
Commits:	39
Dependents:	0
Dependencies:	6
Followers:	1

This repository is Public (Unlisted).

main.cpp@10:976666ffa4ef, 2014-08-23 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning