Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

config.h@69:cc5039284fac, 2016-12-28 (annotated)

Committer:
mjr
Date:
Wed Dec 28 23:32:38 2016 +0000
Revision:
69:cc5039284fac
Parent:
67:c39e66c4e000
Child:
77:0b96f6867312
Slope-based edge detection; disable filtering in plunger readings;

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mjr 17:ab3cec0c8bf4 1 // Pinscape Controller Configuration
mjr 17:ab3cec0c8bf4 2 //
mjr 55:4db125cd11a0 3 // New for 2016: dynamic configuration! To configure the controller,
mjr 55:4db125cd11a0 4 // connect the KL25Z to your PC, install the STANDARD pre-compiled .bin
mjr 55:4db125cd11a0 5 // file, and run the Windows config tool. There's no need (as there was in
mjr 55:4db125cd11a0 6 // the past) to edit the source code or to compile a custom version of the
mjr 55:4db125cd11a0 7 // binary just to customize setup options.
mjr 35:e959ffba78fd 8 //
mjr 55:4db125cd11a0 9 // In earlier versions, configuration was handled mostly with #ifdef and
mjr 55:4db125cd11a0 10 // similar constructs. To customize the setup, you had to create a private
mjr 55:4db125cd11a0 11 // forked copy of the source code, edit the constants defined in config.h,
mjr 55:4db125cd11a0 12 // and compile a custom binary. That's no longer necessary!
mjr 35:e959ffba78fd 13 //
mjr 35:e959ffba78fd 14 // The new approach is to do everything (or as much as possible, anyway)
mjr 35:e959ffba78fd 15 // via the Windows config tool. You shouldn't have to recompile a custom
mjr 35:e959ffba78fd 16 // version just to make a configurable change. Of course, you're still free
mjr 55:4db125cd11a0 17 // to create a custom version if you want to add entirely new features or
mjr 55:4db125cd11a0 18 // make changes that go beyond what the setup tool exposes.
mjr 35:e959ffba78fd 19 //
mjr 35:e959ffba78fd 20
mjr 55:4db125cd11a0 21 // Pre-packaged configuration selection.
mjr 55:4db125cd11a0 22 //
mjr 55:4db125cd11a0 23 // IMPORTANT! If you just want to create a custom configuration, DON'T
mjr 55:4db125cd11a0 24 // modify this file, DON'T use these macros, and DON'T compiler on mbed.
mjr 55:4db125cd11a0 25 // Instead, use the unmodified standard build and configure your system
mjr 55:4db125cd11a0 26 // using the Pinscape Config Tool on Windows. That's easier and better
mjr 55:4db125cd11a0 27 // because the config tool will be able to back up your settings to a
mjr 55:4db125cd11a0 28 // local file on your PC, and will automatically preserve your settings
mjr 55:4db125cd11a0 29 // across upgrades. You won't have to worry about merging your changes
mjr 55:4db125cd11a0 30 // into every update of the repository source code, since you'll never
mjr 55:4db125cd11a0 31 // have to change the source code.
mjr 55:4db125cd11a0 32 //
mjr 55:4db125cd11a0 33 // The different configurations here are purely for testing purposes.
mjr 55:4db125cd11a0 34 // The standard build uses the STANDARD_CONFIG settings, which are the
mjr 55:4db125cd11a0 35 // same as the original version where you had to modify config.h by hand
mjr 55:4db125cd11a0 36 // to customize your system.
mjr 55:4db125cd11a0 37 //
mjr 55:4db125cd11a0 38 #define STANDARD_CONFIG 1 // standard settings, based on v1 base settings
mjr 55:4db125cd11a0 39 #define TEST_CONFIG_EXPAN 0 // configuration for the expansion boards
mjr 55:4db125cd11a0 40 #define TEST_KEEP_PRINTF 0 // for debugging purposes, keep printf() enabled
mjr 55:4db125cd11a0 41 // by leaving the SDA UART GPIO pins unallocated
mjr 48:058ace2aed1d 42
mjr 17:ab3cec0c8bf4 43
mjr 25:e22b88bd783a 44 #ifndef CONFIG_H
mjr 25:e22b88bd783a 45 #define CONFIG_H
mjr 17:ab3cec0c8bf4 46
mjr 35:e959ffba78fd 47 // Plunger type codes
mjr 35:e959ffba78fd 48 // NOTE! These values are part of the external USB interface. New
mjr 35:e959ffba78fd 49 // values can be added, but the meaning of an existing assigned number
mjr 35:e959ffba78fd 50 // should remain fixed to keep the PC-side config tool compatible across
mjr 35:e959ffba78fd 51 // versions.
mjr 35:e959ffba78fd 52 const int PlungerType_None = 0; // no plunger
mjr 35:e959ffba78fd 53 const int PlungerType_TSL1410RS = 1; // TSL1410R linear image sensor (1280x1 pixels, 400dpi), serial mode
mjr 35:e959ffba78fd 54 const int PlungerType_TSL1410RP = 2; // TSL1410R, parallel mode (reads the two sensor sections concurrently)
mjr 69:cc5039284fac 55 const int PlungerType_TSL1412SS = 3; // TSL1412S linear image sensor (1536x1 pixels, 400dpi), serial mode
mjr 69:cc5039284fac 56 const int PlungerType_TSL1412SP = 4; // TSL1412S, parallel mode
mjr 35:e959ffba78fd 57 const int PlungerType_Pot = 5; // potentionmeter
mjr 35:e959ffba78fd 58 const int PlungerType_OptQuad = 6; // AEDR8300 optical quadrature sensor
mjr 35:e959ffba78fd 59 const int PlungerType_MagQuad = 7; // AS5304 magnetic quadrature sensor
mjr 21:5048e16cc9ef 60
mjr 35:e959ffba78fd 61 // Accelerometer orientation codes
mjr 35:e959ffba78fd 62 // These values are part of the external USB interface
mjr 35:e959ffba78fd 63 const int OrientationFront = 0; // USB ports pointed toward front of cabinet
mjr 35:e959ffba78fd 64 const int OrientationLeft = 1; // ports pointed toward left side of cabinet
mjr 35:e959ffba78fd 65 const int OrientationRight = 2; // ports pointed toward right side of cabinet
mjr 35:e959ffba78fd 66 const int OrientationRear = 3; // ports pointed toward back of cabinet
mjr 25:e22b88bd783a 67
mjr 35:e959ffba78fd 68 // input button types
mjr 53:9b2611964afc 69 const int BtnTypeNone = 0; // unused
mjr 35:e959ffba78fd 70 const int BtnTypeJoystick = 1; // joystick button
mjr 53:9b2611964afc 71 const int BtnTypeKey = 2; // keyboard key
mjr 67:c39e66c4e000 72 const int BtnTypeMedia = 3; // media control key
mjr 38:091e511ce8a0 73
mjr 38:091e511ce8a0 74 // input button flags
mjr 38:091e511ce8a0 75 const uint8_t BtnFlagPulse = 0x01; // pulse mode - reports each change in the physical switch state
mjr 38:091e511ce8a0 76 // as a brief press of the logical button/keyboard key
mjr 40:cc0d9814522b 77
mjr 40:cc0d9814522b 78 // button setup structure
mjr 40:cc0d9814522b 79 struct ButtonCfg
mjr 40:cc0d9814522b 80 {
mjr 66:2e3583fbd2f4 81 // physical GPIO pin - a Wire-to-PinName mapping index
mjr 66:2e3583fbd2f4 82 uint8_t pin;
mjr 66:2e3583fbd2f4 83
mjr 66:2e3583fbd2f4 84 // Key type and value reported to the PC
mjr 40:cc0d9814522b 85 uint8_t typ; // key type reported to PC - a BtnTypeXxx value
mjr 53:9b2611964afc 86 uint8_t val; // key value reported - meaning depends on 'typ' value:
mjr 53:9b2611964afc 87 // none -> no PC input reports (val is unused)
mjr 53:9b2611964afc 88 // joystick -> val is joystick button number (1..32)
mjr 53:9b2611964afc 89 // keyboard -> val is USB scan code
mjr 66:2e3583fbd2f4 90
mjr 66:2e3583fbd2f4 91 // Shifted key type and value. These used when the button is pressed
mjr 66:2e3583fbd2f4 92 // while the Local Shift Button is being held down. We send the key
mjr 66:2e3583fbd2f4 93 // code given here instead of the regular typ/val code in this case.
mjr 66:2e3583fbd2f4 94 // If typ2 is BtnTypeNone, we use the regular typ/val code whether or
mjr 66:2e3583fbd2f4 95 // not the shift button is being held.
mjr 66:2e3583fbd2f4 96 uint8_t typ2; // shifted key type
mjr 66:2e3583fbd2f4 97 uint8_t val2; // shifted key value
mjr 66:2e3583fbd2f4 98
mjr 66:2e3583fbd2f4 99 // key flags - a bitwise combination of BtnFlagXxx values
mjr 66:2e3583fbd2f4 100 uint8_t flags;
mjr 40:cc0d9814522b 101
mjr 40:cc0d9814522b 102 void set(uint8_t pin, uint8_t typ, uint8_t val, uint8_t flags = 0)
mjr 40:cc0d9814522b 103 {
mjr 40:cc0d9814522b 104 this->pin = pin;
mjr 40:cc0d9814522b 105 this->typ = typ;
mjr 40:cc0d9814522b 106 this->val = val;
mjr 40:cc0d9814522b 107 this->flags = flags;
mjr 40:cc0d9814522b 108 }
mjr 40:cc0d9814522b 109
mjr 40:cc0d9814522b 110 } __attribute__((packed));
mjr 40:cc0d9814522b 111
mjr 33:d832bcab089e 112
mjr 65:739875521aae 113 // maximum number of input button mappings in configuration
mjr 65:739875521aae 114 const int MAX_BUTTONS = 48;
mjr 65:739875521aae 115
mjr 65:739875521aae 116 // extra slots for virtual buttons (ZB Launch Ball)
mjr 65:739875521aae 117 const int VIRTUAL_BUTTONS = 1; // total number of buttons
mjr 65:739875521aae 118 const int ZBL_BUTTON_CFG = MAX_BUTTONS; // index of ZB Launch Ball slot
mjr 33:d832bcab089e 119
mjr 35:e959ffba78fd 120 // LedWiz output port type codes
mjr 35:e959ffba78fd 121 // These values are part of the external USB interface
mjr 35:e959ffba78fd 122 const int PortTypeDisabled = 0; // port is disabled - not visible to LedWiz/DOF host
mjr 35:e959ffba78fd 123 const int PortTypeGPIOPWM = 1; // GPIO port, PWM enabled
mjr 35:e959ffba78fd 124 const int PortTypeGPIODig = 2; // GPIO port, digital out
mjr 35:e959ffba78fd 125 const int PortTypeTLC5940 = 3; // TLC5940 port
mjr 35:e959ffba78fd 126 const int PortType74HC595 = 4; // 74HC595 port
mjr 53:9b2611964afc 127 const int PortTypeVirtual = 5; // Virtual port - visible to host software, but not connected
mjr 53:9b2611964afc 128 // to a physical output
mjr 17:ab3cec0c8bf4 129
mjr 35:e959ffba78fd 130 // LedWiz output port flag bits
mjr 38:091e511ce8a0 131 const uint8_t PortFlagActiveLow = 0x01; // physical output is active-low
mjr 38:091e511ce8a0 132 const uint8_t PortFlagNoisemaker = 0x02; // noisemaker device - disable when night mode is engaged
mjr 40:cc0d9814522b 133 const uint8_t PortFlagGamma = 0x04; // apply gamma correction to this output
mjr 35:e959ffba78fd 134
mjr 35:e959ffba78fd 135 // maximum number of output ports
mjr 48:058ace2aed1d 136 const int MAX_OUT_PORTS = 128;
mjr 33:d832bcab089e 137
mjr 38:091e511ce8a0 138 // port configuration data
mjr 38:091e511ce8a0 139 struct LedWizPortCfg
mjr 38:091e511ce8a0 140 {
mjr 38:091e511ce8a0 141 uint8_t typ; // port type: a PortTypeXxx value
mjr 38:091e511ce8a0 142 uint8_t pin; // physical output pin: for a GPIO port, this is an index in the
mjr 38:091e511ce8a0 143 // USB-to-PinName mapping list; for a TLC5940 or 74HC595 port, it's
mjr 38:091e511ce8a0 144 // the output number, starting from 0 for OUT0 on the first chip in
mjr 38:091e511ce8a0 145 // the daisy chain. For inactive and virtual ports, it's unused.
mjr 38:091e511ce8a0 146 uint8_t flags; // flags: a combination of PortFlagXxx values
mjr 40:cc0d9814522b 147
mjr 40:cc0d9814522b 148 void set(uint8_t typ, uint8_t pin, uint8_t flags = 0)
mjr 40:cc0d9814522b 149 {
mjr 40:cc0d9814522b 150 this->typ = typ;
mjr 40:cc0d9814522b 151 this->pin = pin;
mjr 40:cc0d9814522b 152 this->flags = flags;
mjr 40:cc0d9814522b 153 }
mjr 40:cc0d9814522b 154
mjr 38:091e511ce8a0 155 } __attribute__((packed));
mjr 38:091e511ce8a0 156
mjr 38:091e511ce8a0 157
mjr 53:9b2611964afc 158 // Convert a physical pin name to a wire pin name
mjr 53:9b2611964afc 159 #define PINNAME_TO_WIRE(p) \
mjr 53:9b2611964afc 160 uint8_t((p) == NC ? 0xFF : \
mjr 53:9b2611964afc 161 (((p) & 0xF000 ) >> (PORT_SHIFT - 5)) | (((p) & 0xFF) >> 2))
mjr 53:9b2611964afc 162
mjr 35:e959ffba78fd 163 struct Config
mjr 35:e959ffba78fd 164 {
mjr 35:e959ffba78fd 165 // set all values to factory defaults
mjr 35:e959ffba78fd 166 void setFactoryDefaults()
mjr 35:e959ffba78fd 167 {
mjr 35:e959ffba78fd 168 // By default, pretend to be LedWiz unit #8. This can be from 1 to 16. Real
mjr 35:e959ffba78fd 169 // LedWiz units have their unit number set at the factory, and the vast majority
mjr 35:e959ffba78fd 170 // are set up as unit #1, since that's the default for anyone who doesn't ask
mjr 35:e959ffba78fd 171 // for a different setting. It seems rare for anyone to use more than one unit
mjr 35:e959ffba78fd 172 // in a pin cab, but for the few who do, the others will probably be numbered
mjr 35:e959ffba78fd 173 // sequentially as #2, #3, etc. It seems safe to assume that no one out there
mjr 48:058ace2aed1d 174 // has a unit #8, so we'll use that as our default. This can be changed from
mjr 48:058ace2aed1d 175 // the config tool, but for the sake of convenience, it's better to pick a
mjr 48:058ace2aed1d 176 // default that most people won't have to change.
mjr 54:fd77a6b2f76c 177 usbVendorID = 0xFAFA; // LedWiz vendor code
mjr 48:058ace2aed1d 178 usbProductID = 0x00F7; // LedWiz product code for unit #8
mjr 61:3c7e6e9ec355 179
mjr 55:4db125cd11a0 180 // Set the default Pinscape unit number to #1. This is a separate identifier
mjr 55:4db125cd11a0 181 // from the LedWiz ID, so you don't have to worry about making this different
mjr 55:4db125cd11a0 182 // from your LedWiz units. Each Pinscape unit should have a unique value for
mjr 55:4db125cd11a0 183 // this ID, though.
mjr 55:4db125cd11a0 184 //
mjr 55:4db125cd11a0 185 // Note that Pinscape unit #1 corresponds to DOF Pinscape #51, PS 2 -> DOF 52,
mjr 55:4db125cd11a0 186 // and so on - just add 50 to get the DOF ID.
mjr 55:4db125cd11a0 187 psUnitNo = 1;
mjr 35:e959ffba78fd 188
mjr 51:57eb311faafa 189 // set a disconnect reboot timeout of 10 seconds by default
mjr 55:4db125cd11a0 190 disconnectRebootTimeout = 10;
mjr 51:57eb311faafa 191
mjr 35:e959ffba78fd 192 // enable joystick reports
mjr 35:e959ffba78fd 193 joystickEnabled = true;
mjr 35:e959ffba78fd 194
mjr 35:e959ffba78fd 195 // assume standard orientation, with USB ports toward front of cabinet
mjr 35:e959ffba78fd 196 orientation = OrientationFront;
mjr 25:e22b88bd783a 197
mjr 52:8298b2a73eb2 198 // assume a basic setup with no expansion boards
mjr 53:9b2611964afc 199 expan.typ = 0;
mjr 53:9b2611964afc 200 expan.vsn = 0;
mjr 53:9b2611964afc 201 memset(expan.ext, 0, sizeof(expan.ext));
mjr 52:8298b2a73eb2 202
mjr 35:e959ffba78fd 203 // assume no plunger is attached
mjr 35:e959ffba78fd 204 plunger.enabled = false;
mjr 35:e959ffba78fd 205 plunger.sensorType = PlungerType_None;
mjr 35:e959ffba78fd 206
mjr 55:4db125cd11a0 207 #if TEST_CONFIG_EXPAN || STANDARD_CONFIG
mjr 43:7a6364d82a41 208 plunger.enabled = true;
mjr 43:7a6364d82a41 209 plunger.sensorType = PlungerType_TSL1410RS;
mjr 53:9b2611964afc 210 plunger.sensorPin[0] = PINNAME_TO_WIRE(PTE20); // SI
mjr 53:9b2611964afc 211 plunger.sensorPin[1] = PINNAME_TO_WIRE(PTE21); // SCLK
mjr 53:9b2611964afc 212 plunger.sensorPin[2] = PINNAME_TO_WIRE(PTB0); // AO1 = PTB0 = ADC0_SE8
mjr 53:9b2611964afc 213 plunger.sensorPin[3] = PINNAME_TO_WIRE(PTE22); // AO2 (parallel mode) = PTE22 = ADC0_SE3
mjr 43:7a6364d82a41 214 #endif
mjr 43:7a6364d82a41 215
mjr 48:058ace2aed1d 216 // default plunger calibration button settings
mjr 55:4db125cd11a0 217 plunger.cal.features = 0x03; // 0x01 = enable button, 0x02 = enable indicator lamp
mjr 55:4db125cd11a0 218 plunger.cal.btn = PINNAME_TO_WIRE(PTE29); // button input (DigitalIn port)
mjr 55:4db125cd11a0 219 plunger.cal.led = PINNAME_TO_WIRE(PTE23); // button output (DigitalOut port)
mjr 35:e959ffba78fd 220
mjr 44:b5ac89b9cd5d 221 // set the default plunger calibration
mjr 44:b5ac89b9cd5d 222 plunger.cal.setDefaults();
mjr 35:e959ffba78fd 223
mjr 35:e959ffba78fd 224 // disable the ZB Launch Ball by default
mjr 53:9b2611964afc 225 plunger.zbLaunchBall.port = 0; // 0 = disabled
mjr 65:739875521aae 226 plunger.zbLaunchBall.keytype = BtnTypeKey; // keyboard key
mjr 61:3c7e6e9ec355 227 plunger.zbLaunchBall.keycode = 0x28; // USB keyboard scan code for Enter key
mjr 61:3c7e6e9ec355 228 plunger.zbLaunchBall.pushDistance = 63; // 63/1000 in == .063" == about 1/16"
mjr 35:e959ffba78fd 229
mjr 35:e959ffba78fd 230 // assume no TV ON switch
mjr 53:9b2611964afc 231 TVON.statusPin = PINNAME_TO_WIRE(NC);
mjr 53:9b2611964afc 232 TVON.latchPin = PINNAME_TO_WIRE(NC);
mjr 53:9b2611964afc 233 TVON.relayPin = PINNAME_TO_WIRE(NC);
mjr 53:9b2611964afc 234 TVON.delayTime = 700; // 7 seconds
mjr 55:4db125cd11a0 235
mjr 55:4db125cd11a0 236 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 237 // expansion board TV ON wiring
mjr 53:9b2611964afc 238 TVON.statusPin = PINNAME_TO_WIRE(PTD2);
mjr 53:9b2611964afc 239 TVON.latchPin = PINNAME_TO_WIRE(PTE0);
mjr 53:9b2611964afc 240 TVON.relayPin = PINNAME_TO_WIRE(PTD3);
mjr 53:9b2611964afc 241 TVON.delayTime = 700; // 7 seconds
mjr 38:091e511ce8a0 242 #endif
mjr 53:9b2611964afc 243
mjr 53:9b2611964afc 244 // assume no night mode switch or indicator lamp
mjr 53:9b2611964afc 245 nightMode.btn = 0;
mjr 53:9b2611964afc 246 nightMode.flags = 0;
mjr 53:9b2611964afc 247 nightMode.port = 0;
mjr 35:e959ffba78fd 248
mjr 35:e959ffba78fd 249 // assume no TLC5940 chips
mjr 35:e959ffba78fd 250 tlc5940.nchips = 0;
mjr 55:4db125cd11a0 251
mjr 55:4db125cd11a0 252 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 253 // for expansion board testing purposes, assume the common setup
mjr 55:4db125cd11a0 254 // with one main board and one power board
mjr 48:058ace2aed1d 255 tlc5940.nchips = 4;
mjr 38:091e511ce8a0 256 #endif
mjr 38:091e511ce8a0 257
mjr 55:4db125cd11a0 258 // Default TLC5940 pin assignments. Note that it's harmless to set
mjr 55:4db125cd11a0 259 // these to valid pins even if no TLC5940 chips are actually present,
mjr 55:4db125cd11a0 260 // since the main program won't allocate the connections if 'nchips'
mjr 55:4db125cd11a0 261 // is zero. This means that the pins are free to be used for other
mjr 55:4db125cd11a0 262 // purposes (such as output ports) if not using TLC5940 chips.
mjr 53:9b2611964afc 263 tlc5940.sin = PINNAME_TO_WIRE(PTC6);
mjr 53:9b2611964afc 264 tlc5940.sclk = PINNAME_TO_WIRE(PTC5);
mjr 53:9b2611964afc 265 tlc5940.xlat = PINNAME_TO_WIRE(PTC10);
mjr 59:94eb9265b6d7 266 tlc5940.blank = PINNAME_TO_WIRE(PTC7);
mjr 59:94eb9265b6d7 267 #if TEST_KEEP_PRINTF
mjr 59:94eb9265b6d7 268 tlc5940.gsclk = PINNAME_TO_WIRE(PTA13); // PTA1 is reserved for SDA printf()
mjr 59:94eb9265b6d7 269 #else
mjr 53:9b2611964afc 270 tlc5940.gsclk = PINNAME_TO_WIRE(PTA1);
mjr 59:94eb9265b6d7 271 #endif
mjr 35:e959ffba78fd 272
mjr 35:e959ffba78fd 273 // assume no 74HC595 chips
mjr 35:e959ffba78fd 274 hc595.nchips = 0;
mjr 55:4db125cd11a0 275
mjr 55:4db125cd11a0 276 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 277 // for expansion board testing purposes, assume one chime board
mjr 48:058ace2aed1d 278 hc595.nchips = 1;
mjr 40:cc0d9814522b 279 #endif
mjr 40:cc0d9814522b 280
mjr 55:4db125cd11a0 281 // Default 74HC595 pin assignments. As with the TLC5940 pins, it's
mjr 55:4db125cd11a0 282 // harmless to assign pins here even if no 74HC595 chips are used,
mjr 55:4db125cd11a0 283 // since the main program won't actually allocate the pins if 'nchips'
mjr 55:4db125cd11a0 284 // is zero.
mjr 53:9b2611964afc 285 hc595.sin = PINNAME_TO_WIRE(PTA5);
mjr 53:9b2611964afc 286 hc595.sclk = PINNAME_TO_WIRE(PTA4);
mjr 53:9b2611964afc 287 hc595.latch = PINNAME_TO_WIRE(PTA12);
mjr 53:9b2611964afc 288 hc595.ena = PINNAME_TO_WIRE(PTD4);
mjr 38:091e511ce8a0 289
mjr 35:e959ffba78fd 290 // initially configure with no LedWiz output ports
mjr 35:e959ffba78fd 291 outPort[0].typ = PortTypeDisabled;
mjr 66:2e3583fbd2f4 292
mjr 66:2e3583fbd2f4 293 // initially configure with no shift key
mjr 66:2e3583fbd2f4 294 shiftButton = 0;
mjr 53:9b2611964afc 295
mjr 35:e959ffba78fd 296 // initially configure with no input buttons
mjr 35:e959ffba78fd 297 for (int i = 0 ; i < MAX_BUTTONS ; ++i)
mjr 53:9b2611964afc 298 button[i].set(PINNAME_TO_WIRE(NC), BtnTypeNone, 0);
mjr 38:091e511ce8a0 299
mjr 55:4db125cd11a0 300 #if STANDARD_CONFIG | TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 301 // For the standard configuration, assign 24 input ports to
mjr 55:4db125cd11a0 302 // joystick buttons 1-24. Assign the same GPIO pins used
mjr 55:4db125cd11a0 303 // in the original v1 default configuration. For expansion
mjr 55:4db125cd11a0 304 // board testing purposes, also assign the input ports, with
mjr 55:4db125cd11a0 305 // the noted differences.
mjr 38:091e511ce8a0 306 for (int i = 0 ; i < 24 ; ++i) {
mjr 55:4db125cd11a0 307 static const int bp[] = {
mjr 53:9b2611964afc 308 PINNAME_TO_WIRE(PTC2), // 1
mjr 53:9b2611964afc 309 PINNAME_TO_WIRE(PTB3), // 2
mjr 53:9b2611964afc 310 PINNAME_TO_WIRE(PTB2), // 3
mjr 53:9b2611964afc 311 PINNAME_TO_WIRE(PTB1), // 4
mjr 53:9b2611964afc 312 PINNAME_TO_WIRE(PTE30), // 5
mjr 48:058ace2aed1d 313 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 314 PINNAME_TO_WIRE(PTC11), // 6 - expansion boards use PTC11 for this, since PTE22
mjr 55:4db125cd11a0 315 // is reserved for a plunger connection
mjr 55:4db125cd11a0 316 #elif STANDARD_CONFIG
mjr 55:4db125cd11a0 317 PINNAME_TO_WIRE(PTE22), // 6 - original standalone setup uses PTE22
mjr 48:058ace2aed1d 318 #endif
mjr 53:9b2611964afc 319 PINNAME_TO_WIRE(PTE5), // 7
mjr 53:9b2611964afc 320 PINNAME_TO_WIRE(PTE4), // 8
mjr 53:9b2611964afc 321 PINNAME_TO_WIRE(PTE3), // 9
mjr 53:9b2611964afc 322 PINNAME_TO_WIRE(PTE2), // 10
mjr 53:9b2611964afc 323 PINNAME_TO_WIRE(PTB11), // 11
mjr 53:9b2611964afc 324 PINNAME_TO_WIRE(PTB10), // 12
mjr 53:9b2611964afc 325 PINNAME_TO_WIRE(PTB9), // 13
mjr 53:9b2611964afc 326 PINNAME_TO_WIRE(PTB8), // 14
mjr 53:9b2611964afc 327 PINNAME_TO_WIRE(PTC12), // 15
mjr 53:9b2611964afc 328 PINNAME_TO_WIRE(PTC13), // 16
mjr 53:9b2611964afc 329 PINNAME_TO_WIRE(PTC16), // 17
mjr 53:9b2611964afc 330 PINNAME_TO_WIRE(PTC17), // 18
mjr 53:9b2611964afc 331 PINNAME_TO_WIRE(PTA16), // 19
mjr 53:9b2611964afc 332 PINNAME_TO_WIRE(PTA17), // 20
mjr 53:9b2611964afc 333 PINNAME_TO_WIRE(PTE31), // 21
mjr 53:9b2611964afc 334 PINNAME_TO_WIRE(PTD6), // 22
mjr 53:9b2611964afc 335 PINNAME_TO_WIRE(PTD7), // 23
mjr 53:9b2611964afc 336 PINNAME_TO_WIRE(PTE1) // 24
mjr 40:cc0d9814522b 337 };
mjr 48:058ace2aed1d 338 button[i].set(bp[i],
mjr 48:058ace2aed1d 339 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 340 // For expansion board testing only, assign the inputs
mjr 55:4db125cd11a0 341 // to keyboard keys A, B, etc. This isn't useful; it's
mjr 55:4db125cd11a0 342 // just for testing purposes. Note that the USB key code
mjr 55:4db125cd11a0 343 // for "A" is 4, "B" is 5, and so on sequentially through
mjr 55:4db125cd11a0 344 // the alphabet.
mjr 55:4db125cd11a0 345 BtnTypeKey, i+4);
mjr 55:4db125cd11a0 346 #elif STANDARD_CONFIG
mjr 55:4db125cd11a0 347 // For the standard configuration, assign the input to
mjr 55:4db125cd11a0 348 // joystick buttons 1-24, as in the original v1 default
mjr 55:4db125cd11a0 349 // configuration.
mjr 55:4db125cd11a0 350 BtnTypeJoystick, i+1);
mjr 48:058ace2aed1d 351 #endif
mjr 48:058ace2aed1d 352
mjr 38:091e511ce8a0 353 }
mjr 38:091e511ce8a0 354 #endif
mjr 38:091e511ce8a0 355
mjr 55:4db125cd11a0 356 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 357 // For testing purposes, configure the basic complement of
mjr 55:4db125cd11a0 358 // expansion board ports. AS MENTIONED ABOVE, THIS IS PURELY FOR
mjr 55:4db125cd11a0 359 // TESTING. DON'T USE THIS METHOD TO CONFIGURE YOUR EXPANSION
mjr 55:4db125cd11a0 360 // BOARDS FOR ACTUAL DEPLOYMENT. It's much easier and cleaner
mjr 55:4db125cd11a0 361 // to use the unmodified standard build, and customize your
mjr 55:4db125cd11a0 362 // installation with the Pinscape Config Tool on Windows.
mjr 40:cc0d9814522b 363 //
mjr 55:4db125cd11a0 364 // For this testing setup, we'll configure one main board, one
mjr 55:4db125cd11a0 365 // power board, and one chime board. The *physical* ports on
mjr 55:4db125cd11a0 366 // the board are shown below. The logical (LedWiz/DOF) numbering
mjr 55:4db125cd11a0 367 // ISN'T sequential through the physical ports, because we want
mjr 55:4db125cd11a0 368 // to arrange the DOF ports so that the most important and most
mjr 55:4db125cd11a0 369 // common toys are assigned to ports 1-32. Those ports are
mjr 55:4db125cd11a0 370 // special because they're accessible to ALL software on the PC,
mjr 55:4db125cd11a0 371 // including older LedWiz-only software such as Future Pinball.
mjr 55:4db125cd11a0 372 // Ports above 32 are accessible only to modern DOF software,
mjr 55:4db125cd11a0 373 // like Visual Pinball and PinballX.
mjr 40:cc0d9814522b 374 //
mjr 40:cc0d9814522b 375 // Main board
mjr 40:cc0d9814522b 376 // TLC ports 0-15 -> flashers
mjr 40:cc0d9814522b 377 // TLC ports 16 -> strobe
mjr 40:cc0d9814522b 378 // TLC ports 17-31 -> flippers
mjr 40:cc0d9814522b 379 // Dig GPIO PTC8 -> knocker (timer-protected outputs)
mjr 40:cc0d9814522b 380 //
mjr 40:cc0d9814522b 381 // Power board:
mjr 40:cc0d9814522b 382 // TLC ports 32-63 -> general purpose outputs
mjr 40:cc0d9814522b 383 //
mjr 40:cc0d9814522b 384 // Chime board:
mjr 40:cc0d9814522b 385 // HC595 ports 0-7 -> timer-protected outputs
mjr 40:cc0d9814522b 386 //
mjr 38:091e511ce8a0 387 {
mjr 38:091e511ce8a0 388 int n = 0;
mjr 40:cc0d9814522b 389
mjr 40:cc0d9814522b 390 // 1-15 = flashers (TLC ports 0-15)
mjr 40:cc0d9814522b 391 // 16 = strobe (TLC port 15)
mjr 40:cc0d9814522b 392 for (int i = 0 ; i < 16 ; ++i)
mjr 40:cc0d9814522b 393 outPort[n++].set(PortTypeTLC5940, i, PortFlagGamma);
mjr 40:cc0d9814522b 394
mjr 53:9b2611964afc 395 // 17 = knocker (PTC8)
mjr 53:9b2611964afc 396 outPort[n++].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC8));
mjr 35:e959ffba78fd 397
mjr 40:cc0d9814522b 398 // 18-49 = power board outputs 1-32 (TLC ports 32-63)
mjr 40:cc0d9814522b 399 for (int i = 0 ; i < 32 ; ++i)
mjr 40:cc0d9814522b 400 outPort[n++].set(PortTypeTLC5940, i+32);
mjr 40:cc0d9814522b 401
mjr 40:cc0d9814522b 402 // 50-65 = flipper RGB (TLC ports 16-31)
mjr 40:cc0d9814522b 403 for (int i = 0 ; i < 16 ; ++i)
mjr 40:cc0d9814522b 404 outPort[n++].set(PortTypeTLC5940, i+16, PortFlagGamma);
mjr 59:94eb9265b6d7 405
mjr 40:cc0d9814522b 406 // 66-73 = chime board ports 1-8 (74HC595 ports 0-7)
mjr 40:cc0d9814522b 407 for (int i = 0 ; i < 8 ; ++i)
mjr 40:cc0d9814522b 408 outPort[n++].set(PortType74HC595, i);
mjr 59:94eb9265b6d7 409
mjr 40:cc0d9814522b 410 // set Disabled to signify end of configured outputs
mjr 38:091e511ce8a0 411 outPort[n].typ = PortTypeDisabled;
mjr 38:091e511ce8a0 412 }
mjr 38:091e511ce8a0 413 #endif
mjr 48:058ace2aed1d 414
mjr 55:4db125cd11a0 415 #if STANDARD_CONFIG
mjr 55:4db125cd11a0 416 //
mjr 55:4db125cd11a0 417 // For the standard build, set up the original complement
mjr 55:4db125cd11a0 418 // of 22 ports from the v1 default onfiguration.
mjr 55:4db125cd11a0 419 //
mjr 55:4db125cd11a0 420 // IMPORTANT! As mentioned above, don't edit this file to
mjr 55:4db125cd11a0 421 // customize this for your machine. Instead, use the unmodified
mjr 55:4db125cd11a0 422 // standard build, and customize your installation using the
mjr 55:4db125cd11a0 423 // Pinscape Config Tool on Windows.
mjr 55:4db125cd11a0 424 //
mjr 48:058ace2aed1d 425 #if TEST_KEEP_PRINTF
mjr 55:4db125cd11a0 426 outPort[ 0].set(PortTypeVirtual, PINNAME_TO_WIRE(NC)); // port 1 = NC to keep debug printf (PTA1 is SDA UART)
mjr 55:4db125cd11a0 427 outPort[ 1].set(PortTypeVirtual, PINNAME_TO_WIRE(NC)); // port 2 = NC to keep debug printf (PTA2 is SDA UART)
mjr 48:058ace2aed1d 428 #else
mjr 53:9b2611964afc 429 outPort[ 0].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA1)); // port 1 = PTA1
mjr 53:9b2611964afc 430 outPort[ 1].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA2)); // port 2 = PTA2
mjr 48:058ace2aed1d 431 #endif
mjr 53:9b2611964afc 432 outPort[ 2].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD4)); // port 3 = PTD4
mjr 53:9b2611964afc 433 outPort[ 3].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA12)); // port 4 = PTA12
mjr 53:9b2611964afc 434 outPort[ 4].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA4)); // port 5 = PTA4
mjr 53:9b2611964afc 435 outPort[ 5].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA5)); // port 6 = PTA5
mjr 53:9b2611964afc 436 outPort[ 6].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA13)); // port 7 = PTA13
mjr 53:9b2611964afc 437 outPort[ 7].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD5)); // port 8 = PTD5
mjr 53:9b2611964afc 438 outPort[ 8].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD0)); // port 9 = PTD0
mjr 53:9b2611964afc 439 outPort[ 9].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD3)); // port 10 = PTD3
mjr 53:9b2611964afc 440 outPort[10].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTD2)); // port 11 = PTD2
mjr 53:9b2611964afc 441 outPort[11].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC8)); // port 12 = PTC8
mjr 53:9b2611964afc 442 outPort[12].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC9)); // port 13 = PTC9
mjr 53:9b2611964afc 443 outPort[13].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC7)); // port 14 = PTC7
mjr 53:9b2611964afc 444 outPort[14].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC0)); // port 15 = PTC0
mjr 53:9b2611964afc 445 outPort[15].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC3)); // port 16 = PTC3
mjr 53:9b2611964afc 446 outPort[16].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC4)); // port 17 = PTC4
mjr 53:9b2611964afc 447 outPort[17].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC5)); // port 18 = PTC5
mjr 53:9b2611964afc 448 outPort[18].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC6)); // port 19 = PTC6
mjr 53:9b2611964afc 449 outPort[19].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC10)); // port 20 = PTC10
mjr 53:9b2611964afc 450 outPort[20].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC11)); // port 21 = PTC11
mjr 53:9b2611964afc 451 outPort[21].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTE0)); // port 22 = PTE0
mjr 48:058ace2aed1d 452 #endif
mjr 35:e959ffba78fd 453 }
mjr 35:e959ffba78fd 454
mjr 35:e959ffba78fd 455 // --- USB DEVICE CONFIGURATION ---
mjr 35:e959ffba78fd 456
mjr 35:e959ffba78fd 457 // USB device identification - vendor ID and product ID. For LedLWiz
mjr 35:e959ffba78fd 458 // emulation, use vendor ID 0xFAFA and product ID 0x00EF + unit#, where
mjr 35:e959ffba78fd 459 // unit# is the nominal LedWiz unit number from 1 to 16. Alternatively,
mjr 35:e959ffba78fd 460 // if LedWiz emulation isn't desired or causes any driver conflicts on
mjr 35:e959ffba78fd 461 // the host, we have a private Pinscape assignment as vendor ID 0x1209
mjr 35:e959ffba78fd 462 // and product ID 0xEAEA (registered with http://pid.codes, a registry
mjr 35:e959ffba78fd 463 // for open-source USB projects).
mjr 35:e959ffba78fd 464 uint16_t usbVendorID;
mjr 35:e959ffba78fd 465 uint16_t usbProductID;
mjr 35:e959ffba78fd 466
mjr 35:e959ffba78fd 467 // Pinscape Controller unit number. This is the nominal unit number,
mjr 35:e959ffba78fd 468 // from 1 to 16. We report this in the status query; DOF uses it to
mjr 53:9b2611964afc 469 // distinguish among Pinscape units. Note that this doesn't affect
mjr 35:e959ffba78fd 470 // the LedWiz unit numbering, which is implied by the USB Product ID.
mjr 35:e959ffba78fd 471 uint8_t psUnitNo;
mjr 35:e959ffba78fd 472
mjr 35:e959ffba78fd 473 // Are joystick reports enabled? Joystick reports can be turned off, to
mjr 35:e959ffba78fd 474 // use the device as purely an output controller.
mjr 35:e959ffba78fd 475 char joystickEnabled;
mjr 35:e959ffba78fd 476
mjr 51:57eb311faafa 477 // Timeout for rebooting the KL25Z when the connection is lost. On some
mjr 51:57eb311faafa 478 // hosts, the mbed USB stack has problems reconnecting after an initial
mjr 51:57eb311faafa 479 // connection is dropped. As a workaround, we can automatically reboot
mjr 51:57eb311faafa 480 // the KL25Z when it detects that it's no longer connected, after the
mjr 51:57eb311faafa 481 // interval set here expires. The timeout is in seconds; setting this
mjr 51:57eb311faafa 482 // to 0 disables the automatic reboot.
mjr 51:57eb311faafa 483 uint8_t disconnectRebootTimeout;
mjr 35:e959ffba78fd 484
mjr 35:e959ffba78fd 485 // --- ACCELEROMETER ---
mjr 35:e959ffba78fd 486
mjr 35:e959ffba78fd 487 // accelerometer orientation (ORIENTATION_xxx value)
mjr 35:e959ffba78fd 488 char orientation;
mjr 35:e959ffba78fd 489
mjr 35:e959ffba78fd 490
mjr 52:8298b2a73eb2 491 // --- EXPANSION BOARDS ---
mjr 52:8298b2a73eb2 492 struct
mjr 52:8298b2a73eb2 493 {
mjr 53:9b2611964afc 494 uint8_t typ; // expansion board set type:
mjr 53:9b2611964afc 495 // 1 -> Pinscape expansion boards
mjr 53:9b2611964afc 496 uint8_t vsn; // board set interface version
mjr 53:9b2611964afc 497 uint8_t ext[3]; // board set type-specific extended data
mjr 52:8298b2a73eb2 498
mjr 52:8298b2a73eb2 499 } expan;
mjr 52:8298b2a73eb2 500
mjr 52:8298b2a73eb2 501
mjr 35:e959ffba78fd 502 // --- PLUNGER CONFIGURATION ---
mjr 35:e959ffba78fd 503 struct
mjr 35:e959ffba78fd 504 {
mjr 35:e959ffba78fd 505 // plunger enabled/disabled
mjr 35:e959ffba78fd 506 char enabled;
mjr 33:d832bcab089e 507
mjr 35:e959ffba78fd 508 // plunger sensor type
mjr 35:e959ffba78fd 509 char sensorType;
mjr 35:e959ffba78fd 510
mjr 35:e959ffba78fd 511 // Plunger sensor pins. To accommodate a wide range of sensor types,
mjr 35:e959ffba78fd 512 // we keep a generic list of 4 pin assignments. The use of each pin
mjr 35:e959ffba78fd 513 // varies by sensor. The lists below are in order of the generic
mjr 35:e959ffba78fd 514 // pins; NC means that the pin isn't used by the sensor. Each pin's
mjr 35:e959ffba78fd 515 // GPIO usage is also listed. Certain usages limit which physical
mjr 35:e959ffba78fd 516 // pins can be assigned (e.g., AnalogIn or PwmOut).
mjr 35:e959ffba78fd 517 //
mjr 35:e959ffba78fd 518 // TSL1410R/1412R, serial: SI (DigitalOut), CLK (DigitalOut), AO (AnalogIn), NC
mjr 35:e959ffba78fd 519 // TSL1410R/1412R, parallel: SI (DigitalOut), CLK (DigitalOut), AO1 (AnalogIn), AO2 (AnalogIn)
mjr 35:e959ffba78fd 520 // Potentiometer: AO (AnalogIn), NC, NC, NC
mjr 35:e959ffba78fd 521 // AEDR8300: A (InterruptIn), B (InterruptIn), NC, NC
mjr 35:e959ffba78fd 522 // AS5304: A (InterruptIn), B (InterruptIn), NC, NC
mjr 53:9b2611964afc 523 //
mjr 53:9b2611964afc 524 // Note! These are stored in uint8_t WIRE format, not PinName format.
mjr 53:9b2611964afc 525 uint8_t sensorPin[4];
mjr 35:e959ffba78fd 526
mjr 53:9b2611964afc 527 // ZB LAUNCH BALL button setup.
mjr 35:e959ffba78fd 528 //
mjr 35:e959ffba78fd 529 // This configures the "ZB Launch Ball" feature in DOF, based on Zeb's (of
mjr 35:e959ffba78fd 530 // zebsboards.com) scheme for using a mechanical plunger as a Launch button.
mjr 35:e959ffba78fd 531 // Set the port to 0 to disable the feature.
mjr 35:e959ffba78fd 532 //
mjr 35:e959ffba78fd 533 // The port number is an LedWiz port number that we monitor for activation.
mjr 53:9b2611964afc 534 // This port isn't meant to be connected to a physical device, although it
mjr 53:9b2611964afc 535 // can be if desired. It's primarily to let the host tell the controller
mjr 53:9b2611964afc 536 // when the ZB Launch feature is active. The port numbering starts at 1;
mjr 53:9b2611964afc 537 // set this to zero to disable the feature.
mjr 35:e959ffba78fd 538 //
mjr 53:9b2611964afc 539 // The key type and code has the same meaning as for a button mapping. This
mjr 53:9b2611964afc 540 // sets the key input sent to the PC when the plunger triggers a launch when
mjr 53:9b2611964afc 541 // the mode is active. For example, set keytype=2 and keycode=0x28 to send
mjr 53:9b2611964afc 542 // the Enter key (which is the key almost all PC pinball software uses for
mjr 53:9b2611964afc 543 // plunger and Launch button input).
mjr 35:e959ffba78fd 544 //
mjr 40:cc0d9814522b 545 // The "push distance" is the distance, in 1/1000 inch units, for registering a
mjr 40:cc0d9814522b 546 // push on the plunger as a button push. If the player pushes the plunger
mjr 40:cc0d9814522b 547 // forward of the rest position by this amount, we'll treat it as pushing the
mjr 40:cc0d9814522b 548 // button, even if the player didn't pull back the plunger first. This lets
mjr 40:cc0d9814522b 549 // the player treat the plunger knob as a button for games where it's meaningful
mjr 35:e959ffba78fd 550 // to hold down the Launch button for specific intervals (e.g., "Championship
mjr 35:e959ffba78fd 551 // Pub").
mjr 35:e959ffba78fd 552 struct
mjr 35:e959ffba78fd 553 {
mjr 53:9b2611964afc 554 uint8_t port;
mjr 53:9b2611964afc 555 uint8_t keytype;
mjr 53:9b2611964afc 556 uint8_t keycode;
mjr 53:9b2611964afc 557 uint16_t pushDistance;
mjr 35:e959ffba78fd 558
mjr 35:e959ffba78fd 559 } zbLaunchBall;
mjr 35:e959ffba78fd 560
mjr 35:e959ffba78fd 561 // --- PLUNGER CALIBRATION ---
mjr 35:e959ffba78fd 562 struct
mjr 35:e959ffba78fd 563 {
mjr 35:e959ffba78fd 564 // has the plunger been calibrated?
mjr 53:9b2611964afc 565 bool calibrated;
mjr 55:4db125cd11a0 566
mjr 55:4db125cd11a0 567 // Feature enable mask:
mjr 55:4db125cd11a0 568 //
mjr 55:4db125cd11a0 569 // 0x01 = calibration button enabled
mjr 55:4db125cd11a0 570 // 0x02 = indicator light enabled
mjr 55:4db125cd11a0 571 uint8_t features;
mjr 35:e959ffba78fd 572
mjr 35:e959ffba78fd 573 // calibration button switch pin
mjr 53:9b2611964afc 574 uint8_t btn;
mjr 35:e959ffba78fd 575
mjr 35:e959ffba78fd 576 // calibration button indicator light pin
mjr 53:9b2611964afc 577 uint8_t led;
mjr 35:e959ffba78fd 578
mjr 48:058ace2aed1d 579 // Plunger calibration min, zero, and max. These are in terms of the
mjr 48:058ace2aed1d 580 // unsigned 16-bit scale (0x0000..0xffff) that we use for the raw sensor
mjr 48:058ace2aed1d 581 // readings.
mjr 48:058ace2aed1d 582 //
mjr 48:058ace2aed1d 583 // The zero point is the rest position (aka park position), where the
mjr 48:058ace2aed1d 584 // plunger is in equilibrium between the main spring and the barrel
mjr 48:058ace2aed1d 585 // spring. In the standard setup, the plunger can travel a small
mjr 48:058ace2aed1d 586 // distance forward of the rest position, because the barrel spring
mjr 48:058ace2aed1d 587 // can be compressed a bit. The minimum is the maximum forward point
mjr 48:058ace2aed1d 588 // where the barrel spring can't be compressed any further.
mjr 48:058ace2aed1d 589 uint16_t min;
mjr 48:058ace2aed1d 590 uint16_t zero;
mjr 48:058ace2aed1d 591 uint16_t max;
mjr 52:8298b2a73eb2 592
mjr 52:8298b2a73eb2 593 // Measured release time, in milliseconds.
mjr 52:8298b2a73eb2 594 uint8_t tRelease;
mjr 35:e959ffba78fd 595
mjr 44:b5ac89b9cd5d 596 // Reset the plunger calibration
mjr 44:b5ac89b9cd5d 597 void setDefaults()
mjr 35:e959ffba78fd 598 {
mjr 44:b5ac89b9cd5d 599 calibrated = false; // not calibrated
mjr 48:058ace2aed1d 600 min = 0; // assume we can go all the way forward...
mjr 48:058ace2aed1d 601 max = 0xffff; // ...and all the way back
mjr 48:058ace2aed1d 602 zero = max/6; // the rest position is usually around 1/2" back = 1/6 of total travel
mjr 52:8298b2a73eb2 603 tRelease = 65; // standard 65ms release time
mjr 44:b5ac89b9cd5d 604 }
mjr 44:b5ac89b9cd5d 605
mjr 44:b5ac89b9cd5d 606 // Begin calibration. This sets each limit to the worst
mjr 44:b5ac89b9cd5d 607 // case point - for example, we set the retracted position
mjr 44:b5ac89b9cd5d 608 // to all the way forward. Each actual reading that comes
mjr 44:b5ac89b9cd5d 609 // in is then checked against the current limit, and if it's
mjr 44:b5ac89b9cd5d 610 // outside of the limit, we reset the limit to the new reading.
mjr 44:b5ac89b9cd5d 611 void begin()
mjr 44:b5ac89b9cd5d 612 {
mjr 48:058ace2aed1d 613 min = 0; // we don't calibrate the maximum forward position, so keep this at zero
mjr 48:058ace2aed1d 614 zero = 0xffff; // set the zero position all the way back
mjr 48:058ace2aed1d 615 max = 0; // set the retracted position all the way forward
mjr 52:8298b2a73eb2 616 tRelease = 65; // revert to a default release time
mjr 35:e959ffba78fd 617 }
mjr 17:ab3cec0c8bf4 618
mjr 35:e959ffba78fd 619 } cal;
mjr 18:5e890ebd0023 620
mjr 35:e959ffba78fd 621 } plunger;
mjr 29:582472d0bc57 622
mjr 35:e959ffba78fd 623
mjr 35:e959ffba78fd 624 // --- TV ON SWITCH ---
mjr 35:e959ffba78fd 625 //
mjr 35:e959ffba78fd 626 // To use the TV ON switch feature, the special power sensing circuitry
mjr 35:e959ffba78fd 627 // implemented on the Expansion Board must be attached (or an equivalent
mjr 35:e959ffba78fd 628 // circuit, as described in the Build Guide). The circuitry lets us
mjr 35:e959ffba78fd 629 // detect power state changes on the secondary power supply.
mjr 35:e959ffba78fd 630 struct
mjr 35:e959ffba78fd 631 {
mjr 35:e959ffba78fd 632 // PSU2 power status sense (DigitalIn pin). This pin goes LOW when the
mjr 35:e959ffba78fd 633 // secondary power supply is turned off, and remains LOW until the LATCH
mjr 35:e959ffba78fd 634 // pin is raised high AND the secondary PSU is turned on. Once HIGH,
mjr 35:e959ffba78fd 635 // it remains HIGH as long as the secondary PSU is on.
mjr 53:9b2611964afc 636 uint8_t statusPin;
mjr 35:e959ffba78fd 637
mjr 35:e959ffba78fd 638 // PSU2 power status latch (DigitalOut pin)
mjr 53:9b2611964afc 639 uint8_t latchPin;
mjr 35:e959ffba78fd 640
mjr 35:e959ffba78fd 641 // TV ON relay pin (DigitalOut pin). This pin controls the TV switch
mjr 35:e959ffba78fd 642 // relay. Raising the pin HIGH turns the relay ON (energizes the coil).
mjr 53:9b2611964afc 643 uint8_t relayPin;
mjr 35:e959ffba78fd 644
mjr 40:cc0d9814522b 645 // TV ON delay time, in 1/100 second units. This is the interval between
mjr 40:cc0d9814522b 646 // sensing that the secondary power supply has turned on and pulsing the
mjr 40:cc0d9814522b 647 // TV ON switch relay.
mjr 40:cc0d9814522b 648 int delayTime;
mjr 35:e959ffba78fd 649
mjr 35:e959ffba78fd 650 } TVON;
mjr 35:e959ffba78fd 651
mjr 53:9b2611964afc 652 // --- Night Mode ---
mjr 53:9b2611964afc 653 struct
mjr 53:9b2611964afc 654 {
mjr 55:4db125cd11a0 655 uint8_t btn; // night mode button number (1..MAX_BUTTONS, 0 = no button)
mjr 53:9b2611964afc 656 uint8_t flags; // flags:
mjr 53:9b2611964afc 657 // 0x01 = on/off switch (if not set, it's a momentary button)
mjr 55:4db125cd11a0 658 uint8_t port; // indicator output port number (1..MAX_OUT_PORTS, 0 = no indicator)
mjr 53:9b2611964afc 659 } nightMode;
mjr 53:9b2611964afc 660
mjr 29:582472d0bc57 661
mjr 35:e959ffba78fd 662 // --- TLC5940NT PWM Controller Chip Setup ---
mjr 35:e959ffba78fd 663 struct
mjr 35:e959ffba78fd 664 {
mjr 35:e959ffba78fd 665 // number of TLC5940NT chips connected in daisy chain
mjr 35:e959ffba78fd 666 int nchips;
mjr 35:e959ffba78fd 667
mjr 53:9b2611964afc 668 // pin connections (wire pin IDs)
mjr 53:9b2611964afc 669 uint8_t sin; // Serial data - must connect to SPIO MOSI -> PTC6 or PTD2
mjr 53:9b2611964afc 670 uint8_t sclk; // Serial clock - must connect to SPIO SCLK -> PTC5 or PTD1
mjr 35:e959ffba78fd 671 // (but don't use PTD1, since it's hard-wired to the on-board blue LED)
mjr 53:9b2611964afc 672 uint8_t xlat; // XLAT (latch) signal - connect to any GPIO pin
mjr 53:9b2611964afc 673 uint8_t blank; // BLANK signal - connect to any GPIO pin
mjr 53:9b2611964afc 674 uint8_t gsclk; // Grayscale clock - must connect to a PWM-out capable pin
mjr 29:582472d0bc57 675
mjr 35:e959ffba78fd 676 } tlc5940;
mjr 35:e959ffba78fd 677
mjr 35:e959ffba78fd 678
mjr 35:e959ffba78fd 679 // --- 74HC595 Shift Register Setup ---
mjr 35:e959ffba78fd 680 struct
mjr 35:e959ffba78fd 681 {
mjr 35:e959ffba78fd 682 // number of 74HC595 chips attached in daisy chain
mjr 35:e959ffba78fd 683 int nchips;
mjr 35:e959ffba78fd 684
mjr 35:e959ffba78fd 685 // pin connections
mjr 53:9b2611964afc 686 uint8_t sin; // Serial data - use any GPIO pin
mjr 53:9b2611964afc 687 uint8_t sclk; // Serial clock - use any GPIO pin
mjr 53:9b2611964afc 688 uint8_t latch; // Latch - use any GPIO pin
mjr 53:9b2611964afc 689 uint8_t ena; // Enable signal - use any GPIO pin
mjr 35:e959ffba78fd 690
mjr 35:e959ffba78fd 691 } hc595;
mjr 34:6b981a2afab7 692
mjr 25:e22b88bd783a 693
mjr 35:e959ffba78fd 694 // --- Button Input Setup ---
mjr 65:739875521aae 695 ButtonCfg button[MAX_BUTTONS + VIRTUAL_BUTTONS] __attribute__((packed));
mjr 66:2e3583fbd2f4 696
mjr 66:2e3583fbd2f4 697 // Shift button index. If this is zero, there's no shift button. If this
mjr 66:2e3583fbd2f4 698 // is nonzero, it's the 1-based index of the shift button in the button[]
mjr 66:2e3583fbd2f4 699 // list.
mjr 66:2e3583fbd2f4 700 //
mjr 66:2e3583fbd2f4 701 // The shift button can also be used as a regular input key. If it is,
mjr 66:2e3583fbd2f4 702 // we DON'T send the input key to the PC as usual when the button is
mjr 66:2e3583fbd2f4 703 // pressed. Instead, we wait to see if the shift function is used:
mjr 66:2e3583fbd2f4 704 //
mjr 66:2e3583fbd2f4 705 // - If another button is pressed while the shift button is held down,
mjr 66:2e3583fbd2f4 706 // and the other button is programmed with a valid key for the shifted/
mjr 66:2e3583fbd2f4 707 // secondary meaning (i.e., typ2 is not BtnTypeNone), the shift function
mjr 66:2e3583fbd2f4 708 // is considered to have been used. We send the secondary meaning of
mjr 66:2e3583fbd2f4 709 // the other button to the PC. The shift key itself generates no PC
mjr 66:2e3583fbd2f4 710 // input in this case, since it has now performed its shift function.
mjr 66:2e3583fbd2f4 711 // Other shifted keys can also be pressed as long as the shift button
mjr 66:2e3583fbd2f4 712 // is held down, and they'll be sent to the PC with their shifted values
mjr 66:2e3583fbd2f4 713 // as well.
mjr 66:2e3583fbd2f4 714 //
mjr 66:2e3583fbd2f4 715 // - If the shift button is released before any other button with a
mjr 66:2e3583fbd2f4 716 // shifted key value is pressed, then the shift button press is taken to
mjr 66:2e3583fbd2f4 717 // be an ordinary key press instead of the shift function. In this case,
mjr 66:2e3583fbd2f4 718 // we report the shift button's key code to the PC when the button is
mjr 66:2e3583fbd2f4 719 // released. We can't report the key code to the PC until then because
mjr 66:2e3583fbd2f4 720 // we don't know until then that another key won't be pressed first.
mjr 66:2e3583fbd2f4 721 // The key press on release is a single timed pulse that's long enough
mjr 66:2e3583fbd2f4 722 // to register as a single key press on the PC, but not long enough to
mjr 66:2e3583fbd2f4 723 // trigger auto-repeat on the PC.
mjr 66:2e3583fbd2f4 724 uint8_t shiftButton;
mjr 17:ab3cec0c8bf4 725
mjr 35:e959ffba78fd 726 // --- LedWiz Output Port Setup ---
mjr 38:091e511ce8a0 727 LedWizPortCfg outPort[MAX_OUT_PORTS] __attribute__((packed)); // LedWiz & extended output ports
mjr 48:058ace2aed1d 728
mjr 17:ab3cec0c8bf4 729 };
mjr 17:ab3cec0c8bf4 730
mjr 35:e959ffba78fd 731 #endif