Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

config.h@116:7a67265d7c19, 2021-10-01 (annotated)

Committer:
arnoz
Date:
Fri Oct 01 08:19:46 2021 +0000
Revision:
116:7a67265d7c19
Parent:
115:39d2eb4b1830 
- Correct information regarding your last merge

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mjr 17:ab3cec0c8bf4 1 // Pinscape Controller Configuration
mjr 17:ab3cec0c8bf4 2 //
mjr 87:8d35c74403af 3 // !!! ATTENTION !!!
mjr 87:8d35c74403af 4 // If you've come here on advice in a forum to change a GPIO setting or
mjr 87:8d35c74403af 5 // to #define a macro to enable the expansion boards, >>>STOP NOW<<<. The
mjr 87:8d35c74403af 6 // advice you found is out of date and no longer applies. You don't need
mjr 87:8d35c74403af 7 // to edit this file or recompile the firmware, and you shouldn't. Instead,
mjr 87:8d35c74403af 8 // use the standard firmware, and set options using the Pinscape Config Tool
mjr 87:8d35c74403af 9 // on your Windows PC. All options that were formerly configurable by
mjr 87:8d35c74403af 10 // editing this file can be selected with the Config Tool. That's much
mjr 87:8d35c74403af 11 // cleaner and easier than editing the source code, and it eliminates the
mjr 87:8d35c74403af 12 // problem of re-synchronizing a private copy of the source code with future
mjr 87:8d35c74403af 13 // updates. With the config tool, you only need the standard firmware build,
mjr 87:8d35c74403af 14 // so future updates are a simple matter of downloading the latest version.
mjr 35:e959ffba78fd 15 //
mjr 35:e959ffba78fd 16 //
mjr 87:8d35c74403af 17 // IN THE PAST (but NOT NOW - see above), configuration was handled mostly
mjr 87:8d35c74403af 18 // with #defines and #ifdefs. To customize the setup, you had to create a
mjr 87:8d35c74403af 19 // private forked copy of the source code, edit the constants defined in
mjr 87:8d35c74403af 20 // config.h, and compile a custom binary. That's no longer necessary because
mjr 87:8d35c74403af 21 // the config tool lets you set all configurable options dynamically. Of
mjr 87:8d35c74403af 22 // course, you're still free to create a custom version if you want to add
mjr 87:8d35c74403af 23 // entirely new features or make changes that go beyond the configurable
mjr 87:8d35c74403af 24 // options.
mjr 35:e959ffba78fd 25 //
mjr 87:8d35c74403af 26 #ifndef CONFIG_H
mjr 87:8d35c74403af 27 #define CONFIG_H
mjr 35:e959ffba78fd 28
mjr 90:aa4e571da8e8 29 #include "USBJoystick.h"
mjr 90:aa4e571da8e8 30
mjr 87:8d35c74403af 31
mjr 87:8d35c74403af 32 // TEST SETTINGS - FOR DEBUGGING PURPOSES ONLY. The macros below select
mjr 87:8d35c74403af 33 // special option combinations for debugging purposes.
mjr 55:4db125cd11a0 34 //
mjr 87:8d35c74403af 35 // IMPORTANT! If you're trying to create a custom configuration because
mjr 87:8d35c74403af 36 // you have a pin conflict or because you're using the expansion boards,
mjr 87:8d35c74403af 37 // DON'T modify this file, DON'T use these macros, and DON'T recompile
mjr 87:8d35c74403af 38 // the firmware. Use the Config Tool on your Windows PC instead.
mjr 55:4db125cd11a0 39 #define STANDARD_CONFIG 1 // standard settings, based on v1 base settings
mjr 55:4db125cd11a0 40 #define TEST_CONFIG_EXPAN 0 // configuration for the expansion boards
mjr 80:94dc2946871b 41 #define TEST_KEEP_PRINTF 0 // for debugging purposes, keep printf() enabled
mjr 55:4db125cd11a0 42 // by leaving the SDA UART GPIO pins unallocated
mjr 48:058ace2aed1d 43
mjr 35:e959ffba78fd 44 // Plunger type codes
mjr 35:e959ffba78fd 45 // NOTE! These values are part of the external USB interface. New
mjr 35:e959ffba78fd 46 // values can be added, but the meaning of an existing assigned number
mjr 35:e959ffba78fd 47 // should remain fixed to keep the PC-side config tool compatible across
mjr 35:e959ffba78fd 48 // versions.
mjr 35:e959ffba78fd 49 const int PlungerType_None = 0; // no plunger
mjr 82:4f6209cb5c33 50 const int PlungerType_TSL1410R = 1; // TSL1410R linear image sensor (1280x1 pixels, 400dpi), serial mode, edge detection
mjr 82:4f6209cb5c33 51 const int PlungerType_TSL1412S = 3; // TSL1412S linear image sensor (1536x1 pixels, 400dpi), serial mode, edge detection
mjr 35:e959ffba78fd 52 const int PlungerType_Pot = 5; // potentionmeter
mjr 35:e959ffba78fd 53 const int PlungerType_OptQuad = 6; // AEDR8300 optical quadrature sensor
mjr 35:e959ffba78fd 54 const int PlungerType_MagQuad = 7; // AS5304 magnetic quadrature sensor
mjr 100:1ff35c07217c 55 const int PlungerType_TSL1401CL = 8; // TSL1401CL linear image sensor (128x1 pixels, 400dpi), bar code reader
mjr 82:4f6209cb5c33 56 const int PlungerType_VL6180X = 9; // VL6180X time-of-flight distance sensor
mjr 100:1ff35c07217c 57 const int PlungerType_AEAT6012 = 10; // AEAT-6012-A06 magnetic rotary encoder; absolute angle sensing, 12-bit precision
mjr 100:1ff35c07217c 58 const int PlungerType_TCD1103 = 11; // Toshiba TCD1103GFG linear image sensor (1500x1 pixels, ~4600dpi), edge detection
mjr 111:42dc75fbe623 59 const int PlungerType_VCNL4010 = 12; // VCNL4010 IR proximity sensor
mjr 82:4f6209cb5c33 60
mjr 82:4f6209cb5c33 61 // Plunger auto-zero flags
mjr 82:4f6209cb5c33 62 const int PlungerAutoZeroEnabled = 0x01; // auto-zeroing enabled
mjr 21:5048e16cc9ef 63
mjr 35:e959ffba78fd 64 // Accelerometer orientation codes
mjr 35:e959ffba78fd 65 // These values are part of the external USB interface
mjr 35:e959ffba78fd 66 const int OrientationFront = 0; // USB ports pointed toward front of cabinet
mjr 35:e959ffba78fd 67 const int OrientationLeft = 1; // ports pointed toward left side of cabinet
mjr 35:e959ffba78fd 68 const int OrientationRight = 2; // ports pointed toward right side of cabinet
mjr 35:e959ffba78fd 69 const int OrientationRear = 3; // ports pointed toward back of cabinet
mjr 25:e22b88bd783a 70
mjr 77:0b96f6867312 71 // Accelerometer dynamic range codes
mjr 77:0b96f6867312 72 const int AccelRange1G = 0; // +/-1G
mjr 77:0b96f6867312 73 const int AccelRange2G = 1; // +/-2G
mjr 77:0b96f6867312 74 const int AccelRange4G = 2; // +/-4G
mjr 77:0b96f6867312 75 const int AccelRange8G = 3; // +/-8G
mjr 77:0b96f6867312 76
mjr 35:e959ffba78fd 77 // input button types
mjr 53:9b2611964afc 78 const int BtnTypeNone = 0; // unused
mjr 35:e959ffba78fd 79 const int BtnTypeJoystick = 1; // joystick button
mjr 53:9b2611964afc 80 const int BtnTypeKey = 2; // keyboard key
mjr 67:c39e66c4e000 81 const int BtnTypeMedia = 3; // media control key
mjr 38:091e511ce8a0 82
mjr 38:091e511ce8a0 83 // input button flags
mjr 38:091e511ce8a0 84 const uint8_t BtnFlagPulse = 0x01; // pulse mode - reports each change in the physical switch state
mjr 38:091e511ce8a0 85 // as a brief press of the logical button/keyboard key
mjr 40:cc0d9814522b 86
mjr 40:cc0d9814522b 87 // button setup structure
mjr 40:cc0d9814522b 88 struct ButtonCfg
mjr 40:cc0d9814522b 89 {
mjr 66:2e3583fbd2f4 90 // physical GPIO pin - a Wire-to-PinName mapping index
mjr 66:2e3583fbd2f4 91 uint8_t pin;
mjr 66:2e3583fbd2f4 92
mjr 66:2e3583fbd2f4 93 // Key type and value reported to the PC
mjr 40:cc0d9814522b 94 uint8_t typ; // key type reported to PC - a BtnTypeXxx value
mjr 53:9b2611964afc 95 uint8_t val; // key value reported - meaning depends on 'typ' value:
mjr 53:9b2611964afc 96 // none -> no PC input reports (val is unused)
mjr 53:9b2611964afc 97 // joystick -> val is joystick button number (1..32)
mjr 53:9b2611964afc 98 // keyboard -> val is USB scan code
mjr 77:0b96f6867312 99 uint8_t IRCommand; // IR command to send when the button is pressed, as
mjr 77:0b96f6867312 100 // an IR command slot number: 1..MAX_IR_CODES, or 0
mjr 77:0b96f6867312 101 // if no IR command is to be sent
mjr 66:2e3583fbd2f4 102
mjr 66:2e3583fbd2f4 103 // Shifted key type and value. These used when the button is pressed
mjr 66:2e3583fbd2f4 104 // while the Local Shift Button is being held down. We send the key
mjr 66:2e3583fbd2f4 105 // code given here instead of the regular typ/val code in this case.
mjr 66:2e3583fbd2f4 106 // If typ2 is BtnTypeNone, we use the regular typ/val code whether or
mjr 66:2e3583fbd2f4 107 // not the shift button is being held.
mjr 66:2e3583fbd2f4 108 uint8_t typ2; // shifted key type
mjr 66:2e3583fbd2f4 109 uint8_t val2; // shifted key value
mjr 77:0b96f6867312 110 uint8_t IRCommand2; // IR command to send when shifted button is pressed
mjr 66:2e3583fbd2f4 111
mjr 66:2e3583fbd2f4 112 // key flags - a bitwise combination of BtnFlagXxx values
mjr 66:2e3583fbd2f4 113 uint8_t flags;
mjr 40:cc0d9814522b 114
mjr 40:cc0d9814522b 115 void set(uint8_t pin, uint8_t typ, uint8_t val, uint8_t flags = 0)
mjr 40:cc0d9814522b 116 {
mjr 40:cc0d9814522b 117 this->pin = pin;
mjr 40:cc0d9814522b 118 this->typ = typ;
mjr 40:cc0d9814522b 119 this->val = val;
mjr 77:0b96f6867312 120 this->IRCommand = 0;
mjr 40:cc0d9814522b 121 this->flags = flags;
mjr 77:0b96f6867312 122 this->typ2 = 0;
mjr 77:0b96f6867312 123 this->val2 = 0;
mjr 77:0b96f6867312 124 this->IRCommand2 = 0;
mjr 40:cc0d9814522b 125 }
mjr 40:cc0d9814522b 126
mjr 40:cc0d9814522b 127 } __attribute__((packed));
mjr 40:cc0d9814522b 128
mjr 33:d832bcab089e 129
mjr 65:739875521aae 130 // maximum number of input button mappings in configuration
mjr 65:739875521aae 131 const int MAX_BUTTONS = 48;
mjr 65:739875521aae 132
mjr 65:739875521aae 133 // extra slots for virtual buttons (ZB Launch Ball)
mjr 89:c43cd923401c 134 const int VIRTUAL_BUTTONS = 1; // total number of buttons
mjr 89:c43cd923401c 135 const int ZBL_BUTTON_CFG = MAX_BUTTONS; // index of ZB Launch Ball slot
mjr 33:d832bcab089e 136
mjr 35:e959ffba78fd 137 // LedWiz output port type codes
mjr 35:e959ffba78fd 138 // These values are part of the external USB interface
mjr 89:c43cd923401c 139 const int PortTypeDisabled = 0; // port is disabled - not visible to LedWiz/DOF host
mjr 89:c43cd923401c 140 const int PortTypeGPIOPWM = 1; // GPIO port, PWM enabled
mjr 89:c43cd923401c 141 const int PortTypeGPIODig = 2; // GPIO port, digital out
mjr 89:c43cd923401c 142 const int PortTypeTLC5940 = 3; // TLC5940 port
mjr 89:c43cd923401c 143 const int PortType74HC595 = 4; // 74HC595 port
mjr 89:c43cd923401c 144 const int PortTypeVirtual = 5; // Virtual port - visible to host software, but not connected
mjr 89:c43cd923401c 145 // to a physical output
mjr 89:c43cd923401c 146 const int PortTypeTLC59116 = 6; // TLC59116 port
mjr 17:ab3cec0c8bf4 147
mjr 35:e959ffba78fd 148 // LedWiz output port flag bits
mjr 89:c43cd923401c 149 const uint8_t PortFlagActiveLow = 0x01; // physical output is active-low
mjr 89:c43cd923401c 150 const uint8_t PortFlagNoisemaker = 0x02; // noisemaker device - disable when night mode is engaged
mjr 89:c43cd923401c 151 const uint8_t PortFlagGamma = 0x04; // apply gamma correction to this output
mjr 89:c43cd923401c 152 const uint8_t PortFlagFlipperLogic = 0x08; // enable Flipper Logic on the port (timed power limitation)
mjr 99:8139b0c274f4 153 const uint8_t PortFlagChimeLogic = 0x10; // enable Chime Logic on this port (min/max time limits)
mjr 35:e959ffba78fd 154
mjr 35:e959ffba78fd 155 // maximum number of output ports
mjr 48:058ace2aed1d 156 const int MAX_OUT_PORTS = 128;
mjr 33:d832bcab089e 157
mjr 38:091e511ce8a0 158 // port configuration data
mjr 38:091e511ce8a0 159 struct LedWizPortCfg
mjr 38:091e511ce8a0 160 {
mjr 89:c43cd923401c 161 // port type: a PortTypeXxx value
mjr 89:c43cd923401c 162 uint8_t typ;
mjr 40:cc0d9814522b 163
mjr 89:c43cd923401c 164 // physical output pin:
mjr 89:c43cd923401c 165 //
mjr 89:c43cd923401c 166 // - for a GPIO port, this is an index in the
mjr 89:c43cd923401c 167 // USB-to-PinName mapping list
mjr 89:c43cd923401c 168 //
mjr 89:c43cd923401c 169 // - for a TLC5940 or 74HC595 port, it's the output
mjr 89:c43cd923401c 170 // number in the overall daisy chain, starting
mjr 89:c43cd923401c 171 // from 0 for OUT0 on the first chip in the chain
mjr 89:c43cd923401c 172 //
mjr 89:c43cd923401c 173 // - for a TLC59116, the high 4 bits are the chip
mjr 89:c43cd923401c 174 // address (the low 4 bits of the address only),
mjr 89:c43cd923401c 175 // and the low 4 bits are the output number on
mjr 89:c43cd923401c 176 // the chip
mjr 89:c43cd923401c 177 //
mjr 89:c43cd923401c 178 // - for inactive and virtual ports, this is unused
mjr 89:c43cd923401c 179 //
mjr 89:c43cd923401c 180 uint8_t pin;
mjr 89:c43cd923401c 181
mjr 89:c43cd923401c 182 // flags: a combination of PortFlagXxx values
mjr 89:c43cd923401c 183 uint8_t flags;
mjr 89:c43cd923401c 184
mjr 89:c43cd923401c 185 // flipper logic properties:
mjr 89:c43cd923401c 186 //
mjr 98:4df3c0f7e707 187 // - high 4 bits (0xF0) give full-power time
mjr 89:c43cd923401c 188 //
mjr 89:c43cd923401c 189 // - low 4 bits (0x0F) give reduced power level (used
mjr 89:c43cd923401c 190 // after full-power time expires), in 6.66% units
mjr 89:c43cd923401c 191 //
mjr 89:c43cd923401c 192 uint8_t flipperLogic;
mjr 89:c43cd923401c 193
mjr 99:8139b0c274f4 194 void set(uint8_t typ, uint8_t pin, uint8_t flags = 0, uint8_t flipperLogic = 0)
mjr 40:cc0d9814522b 195 {
mjr 40:cc0d9814522b 196 this->typ = typ;
mjr 40:cc0d9814522b 197 this->pin = pin;
mjr 40:cc0d9814522b 198 this->flags = flags;
mjr 89:c43cd923401c 199 this->flipperLogic = flipperLogic;
mjr 40:cc0d9814522b 200 }
mjr 40:cc0d9814522b 201
mjr 77:0b96f6867312 202 } __attribute__ ((packed));
mjr 77:0b96f6867312 203
mjr 77:0b96f6867312 204 // IR command configuration flags
mjr 77:0b96f6867312 205 const uint8_t IRFlagTVON = 0x01; // send command at TV ON time
mjr 77:0b96f6867312 206 const uint8_t IRFlagDittos = 0x02; // use "ditto" codes on send
mjr 77:0b96f6867312 207
mjr 77:0b96f6867312 208 // IR command configuration data
mjr 77:0b96f6867312 209 struct IRCommandCfg
mjr 77:0b96f6867312 210 {
mjr 77:0b96f6867312 211 uint8_t flags; // flags: a combination of IRFlagXxx values
mjr 77:0b96f6867312 212 uint8_t keytype; // key type to send when IR command is received
mjr 77:0b96f6867312 213 uint8_t keycode; // key code to send when IR command is received
mjr 77:0b96f6867312 214 uint8_t protocol; // IR protocol ID (see IRRemote/IRProtocolID.h)
mjr 77:0b96f6867312 215 struct
mjr 77:0b96f6867312 216 {
mjr 77:0b96f6867312 217 uint32_t lo; // low 32 bits of code
mjr 77:0b96f6867312 218 uint32_t hi; // high 32 bits of code
mjr 77:0b96f6867312 219 } code; // 64-bit command code (protocol-specific; see IRProtocols.h)
mjr 77:0b96f6867312 220 } __attribute__ ((packed));
mjr 77:0b96f6867312 221
mjr 77:0b96f6867312 222 // Maximum number of IR commands
mjr 77:0b96f6867312 223 const int MAX_IR_CODES = 16;
mjr 38:091e511ce8a0 224
mjr 38:091e511ce8a0 225
mjr 53:9b2611964afc 226 // Convert a physical pin name to a wire pin name
mjr 53:9b2611964afc 227 #define PINNAME_TO_WIRE(p) \
mjr 53:9b2611964afc 228 uint8_t((p) == NC ? 0xFF : \
mjr 53:9b2611964afc 229 (((p) & 0xF000 ) >> (PORT_SHIFT - 5)) | (((p) & 0xFF) >> 2))
mjr 53:9b2611964afc 230
mjr 35:e959ffba78fd 231 struct Config
mjr 35:e959ffba78fd 232 {
mjr 35:e959ffba78fd 233 // set all values to factory defaults
mjr 35:e959ffba78fd 234 void setFactoryDefaults()
mjr 35:e959ffba78fd 235 {
mjr 35:e959ffba78fd 236 // By default, pretend to be LedWiz unit #8. This can be from 1 to 16. Real
mjr 35:e959ffba78fd 237 // LedWiz units have their unit number set at the factory, and the vast majority
mjr 35:e959ffba78fd 238 // are set up as unit #1, since that's the default for anyone who doesn't ask
mjr 35:e959ffba78fd 239 // for a different setting. It seems rare for anyone to use more than one unit
mjr 35:e959ffba78fd 240 // in a pin cab, but for the few who do, the others will probably be numbered
mjr 35:e959ffba78fd 241 // sequentially as #2, #3, etc. It seems safe to assume that no one out there
mjr 48:058ace2aed1d 242 // has a unit #8, so we'll use that as our default. This can be changed from
mjr 48:058ace2aed1d 243 // the config tool, but for the sake of convenience, it's better to pick a
mjr 48:058ace2aed1d 244 // default that most people won't have to change.
mjr 54:fd77a6b2f76c 245 usbVendorID = 0xFAFA; // LedWiz vendor code
mjr 48:058ace2aed1d 246 usbProductID = 0x00F7; // LedWiz product code for unit #8
mjr 61:3c7e6e9ec355 247
mjr 55:4db125cd11a0 248 // Set the default Pinscape unit number to #1. This is a separate identifier
mjr 55:4db125cd11a0 249 // from the LedWiz ID, so you don't have to worry about making this different
mjr 55:4db125cd11a0 250 // from your LedWiz units. Each Pinscape unit should have a unique value for
mjr 55:4db125cd11a0 251 // this ID, though.
mjr 55:4db125cd11a0 252 //
mjr 55:4db125cd11a0 253 // Note that Pinscape unit #1 corresponds to DOF Pinscape #51, PS 2 -> DOF 52,
mjr 55:4db125cd11a0 254 // and so on - just add 50 to get the DOF ID.
mjr 55:4db125cd11a0 255 psUnitNo = 1;
mjr 35:e959ffba78fd 256
mjr 51:57eb311faafa 257 // set a disconnect reboot timeout of 10 seconds by default
mjr 55:4db125cd11a0 258 disconnectRebootTimeout = 10;
mjr 51:57eb311faafa 259
mjr 35:e959ffba78fd 260 // enable joystick reports
mjr 35:e959ffba78fd 261 joystickEnabled = true;
mjr 35:e959ffba78fd 262
mjr 90:aa4e571da8e8 263 // use the XYZ axis format
mjr 90:aa4e571da8e8 264 joystickAxisFormat = USBJoystick::AXIS_FORMAT_XYZ;
mjr 90:aa4e571da8e8 265
mjr 92:f264fbaa1be5 266 // send reports every 8.33ms by default (120 Hz, 2X the typical video
mjr 92:f264fbaa1be5 267 // refresh rate)
mjr 92:f264fbaa1be5 268 jsReportInterval_us = 8333;
mjr 92:f264fbaa1be5 269
mjr 35:e959ffba78fd 270 // assume standard orientation, with USB ports toward front of cabinet
mjr 78:1e00b3fa11af 271 accel.orientation = OrientationFront;
mjr 78:1e00b3fa11af 272
mjr 78:1e00b3fa11af 273 // default dynamic range +/-1G
mjr 78:1e00b3fa11af 274 accel.range = AccelRange1G;
mjr 78:1e00b3fa11af 275
mjr 78:1e00b3fa11af 276 // default auto-centering time
mjr 78:1e00b3fa11af 277 accel.autoCenterTime = 0;
mjr 92:f264fbaa1be5 278
mjr 92:f264fbaa1be5 279 // take a new accelerometer reading on every other joystick report
mjr 92:f264fbaa1be5 280 accel.stutter = 2;
mjr 25:e22b88bd783a 281
mjr 52:8298b2a73eb2 282 // assume a basic setup with no expansion boards
mjr 53:9b2611964afc 283 expan.typ = 0;
mjr 53:9b2611964afc 284 expan.vsn = 0;
mjr 53:9b2611964afc 285 memset(expan.ext, 0, sizeof(expan.ext));
mjr 52:8298b2a73eb2 286
mjr 35:e959ffba78fd 287 // assume no plunger is attached
mjr 77:0b96f6867312 288 plunger.enabled = 0x00;
mjr 35:e959ffba78fd 289 plunger.sensorType = PlungerType_None;
mjr 35:e959ffba78fd 290
mjr 91:ae9be42652bf 291 // no jitter filter
mjr 91:ae9be42652bf 292 plunger.jitterWindow = 0;
mjr 91:ae9be42652bf 293
mjr 91:ae9be42652bf 294 // normal orientation
mjr 91:ae9be42652bf 295 plunger.reverseOrientation = false;
mjr 91:ae9be42652bf 296
mjr 55:4db125cd11a0 297 #if TEST_CONFIG_EXPAN || STANDARD_CONFIG
mjr 77:0b96f6867312 298 plunger.enabled = 0x01;
mjr 82:4f6209cb5c33 299 plunger.sensorType = PlungerType_TSL1410R;
mjr 53:9b2611964afc 300 plunger.sensorPin[0] = PINNAME_TO_WIRE(PTE20); // SI
mjr 53:9b2611964afc 301 plunger.sensorPin[1] = PINNAME_TO_WIRE(PTE21); // SCLK
mjr 53:9b2611964afc 302 plunger.sensorPin[2] = PINNAME_TO_WIRE(PTB0); // AO1 = PTB0 = ADC0_SE8
mjr 53:9b2611964afc 303 plunger.sensorPin[3] = PINNAME_TO_WIRE(PTE22); // AO2 (parallel mode) = PTE22 = ADC0_SE3
mjr 43:7a6364d82a41 304 #endif
mjr 43:7a6364d82a41 305
mjr 48:058ace2aed1d 306 // default plunger calibration button settings
mjr 55:4db125cd11a0 307 plunger.cal.features = 0x03; // 0x01 = enable button, 0x02 = enable indicator lamp
mjr 55:4db125cd11a0 308 plunger.cal.btn = PINNAME_TO_WIRE(PTE29); // button input (DigitalIn port)
mjr 55:4db125cd11a0 309 plunger.cal.led = PINNAME_TO_WIRE(PTE23); // button output (DigitalOut port)
mjr 35:e959ffba78fd 310
mjr 44:b5ac89b9cd5d 311 // set the default plunger calibration
mjr 44:b5ac89b9cd5d 312 plunger.cal.setDefaults();
mjr 35:e959ffba78fd 313
mjr 35:e959ffba78fd 314 // disable the ZB Launch Ball by default
mjr 53:9b2611964afc 315 plunger.zbLaunchBall.port = 0; // 0 = disabled
mjr 65:739875521aae 316 plunger.zbLaunchBall.keytype = BtnTypeKey; // keyboard key
mjr 61:3c7e6e9ec355 317 plunger.zbLaunchBall.keycode = 0x28; // USB keyboard scan code for Enter key
mjr 61:3c7e6e9ec355 318 plunger.zbLaunchBall.pushDistance = 63; // 63/1000 in == .063" == about 1/16"
mjr 35:e959ffba78fd 319
mjr 35:e959ffba78fd 320 // assume no TV ON switch
mjr 53:9b2611964afc 321 TVON.statusPin = PINNAME_TO_WIRE(NC);
mjr 53:9b2611964afc 322 TVON.latchPin = PINNAME_TO_WIRE(NC);
mjr 53:9b2611964afc 323 TVON.relayPin = PINNAME_TO_WIRE(NC);
mjr 53:9b2611964afc 324 TVON.delayTime = 700; // 7 seconds
mjr 55:4db125cd11a0 325
mjr 55:4db125cd11a0 326 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 327 // expansion board TV ON wiring
mjr 53:9b2611964afc 328 TVON.statusPin = PINNAME_TO_WIRE(PTD2);
mjr 53:9b2611964afc 329 TVON.latchPin = PINNAME_TO_WIRE(PTE0);
mjr 53:9b2611964afc 330 TVON.relayPin = PINNAME_TO_WIRE(PTD3);
mjr 53:9b2611964afc 331 TVON.delayTime = 700; // 7 seconds
mjr 38:091e511ce8a0 332 #endif
mjr 53:9b2611964afc 333
mjr 53:9b2611964afc 334 // assume no night mode switch or indicator lamp
mjr 53:9b2611964afc 335 nightMode.btn = 0;
mjr 53:9b2611964afc 336 nightMode.flags = 0;
mjr 53:9b2611964afc 337 nightMode.port = 0;
mjr 35:e959ffba78fd 338
mjr 35:e959ffba78fd 339 // assume no TLC5940 chips
mjr 35:e959ffba78fd 340 tlc5940.nchips = 0;
mjr 55:4db125cd11a0 341
mjr 55:4db125cd11a0 342 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 343 // for expansion board testing purposes, assume the common setup
mjr 55:4db125cd11a0 344 // with one main board and one power board
mjr 48:058ace2aed1d 345 tlc5940.nchips = 4;
mjr 38:091e511ce8a0 346 #endif
mjr 38:091e511ce8a0 347
mjr 55:4db125cd11a0 348 // Default TLC5940 pin assignments. Note that it's harmless to set
mjr 55:4db125cd11a0 349 // these to valid pins even if no TLC5940 chips are actually present,
mjr 55:4db125cd11a0 350 // since the main program won't allocate the connections if 'nchips'
mjr 55:4db125cd11a0 351 // is zero. This means that the pins are free to be used for other
mjr 55:4db125cd11a0 352 // purposes (such as output ports) if not using TLC5940 chips.
mjr 53:9b2611964afc 353 tlc5940.sin = PINNAME_TO_WIRE(PTC6);
mjr 53:9b2611964afc 354 tlc5940.sclk = PINNAME_TO_WIRE(PTC5);
mjr 53:9b2611964afc 355 tlc5940.xlat = PINNAME_TO_WIRE(PTC10);
mjr 59:94eb9265b6d7 356 tlc5940.blank = PINNAME_TO_WIRE(PTC7);
mjr 59:94eb9265b6d7 357 #if TEST_KEEP_PRINTF
mjr 59:94eb9265b6d7 358 tlc5940.gsclk = PINNAME_TO_WIRE(PTA13); // PTA1 is reserved for SDA printf()
mjr 59:94eb9265b6d7 359 #else
mjr 53:9b2611964afc 360 tlc5940.gsclk = PINNAME_TO_WIRE(PTA1);
mjr 59:94eb9265b6d7 361 #endif
mjr 35:e959ffba78fd 362
mjr 35:e959ffba78fd 363 // assume no 74HC595 chips
mjr 35:e959ffba78fd 364 hc595.nchips = 0;
mjr 55:4db125cd11a0 365
mjr 55:4db125cd11a0 366 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 367 // for expansion board testing purposes, assume one chime board
mjr 48:058ace2aed1d 368 hc595.nchips = 1;
mjr 40:cc0d9814522b 369 #endif
mjr 40:cc0d9814522b 370
mjr 55:4db125cd11a0 371 // Default 74HC595 pin assignments. As with the TLC5940 pins, it's
mjr 55:4db125cd11a0 372 // harmless to assign pins here even if no 74HC595 chips are used,
mjr 55:4db125cd11a0 373 // since the main program won't actually allocate the pins if 'nchips'
mjr 55:4db125cd11a0 374 // is zero.
mjr 53:9b2611964afc 375 hc595.sin = PINNAME_TO_WIRE(PTA5);
mjr 53:9b2611964afc 376 hc595.sclk = PINNAME_TO_WIRE(PTA4);
mjr 53:9b2611964afc 377 hc595.latch = PINNAME_TO_WIRE(PTA12);
mjr 53:9b2611964afc 378 hc595.ena = PINNAME_TO_WIRE(PTD4);
mjr 38:091e511ce8a0 379
mjr 87:8d35c74403af 380 // disable all TLC59116 chips by default
mjr 87:8d35c74403af 381 tlc59116.chipMask = 0;
mjr 87:8d35c74403af 382
mjr 87:8d35c74403af 383 // Default TLC59116 pin assignments
mjr 87:8d35c74403af 384 tlc59116.sda = PINNAME_TO_WIRE(PTC6);
mjr 87:8d35c74403af 385 tlc59116.scl = PINNAME_TO_WIRE(PTC5);
mjr 87:8d35c74403af 386 tlc59116.reset = PINNAME_TO_WIRE(PTC10);
mjr 77:0b96f6867312 387
mjr 77:0b96f6867312 388 // Default IR hardware pin assignments. On the expansion boards,
mjr 77:0b96f6867312 389 // the sensor is connected to PTA13, and the emitter LED is on PTC9.
mjr 77:0b96f6867312 390 #if TEST_CONFIG_EXPAN
mjr 77:0b96f6867312 391 IR.sensor = PINNAME_TO_WIRE(PTA13);
mjr 77:0b96f6867312 392 IR.emitter = PINNAME_TO_WIRE(PTC9);
mjr 77:0b96f6867312 393 #else
mjr 77:0b96f6867312 394 IR.sensor = PINNAME_TO_WIRE(NC);
mjr 77:0b96f6867312 395 IR.emitter = PINNAME_TO_WIRE(NC);
mjr 77:0b96f6867312 396 #endif
mjr 77:0b96f6867312 397
mjr 77:0b96f6867312 398 // clear out all IR slots
mjr 77:0b96f6867312 399 memset(IRCommand, 0, sizeof(IRCommand));
mjr 77:0b96f6867312 400 for (int i = 0 ; i < MAX_IR_CODES ; ++i)
mjr 77:0b96f6867312 401 {
mjr 77:0b96f6867312 402 IRCommand[i].protocol = 0;
mjr 77:0b96f6867312 403 IRCommand[i].keytype = BtnTypeNone;
mjr 77:0b96f6867312 404 }
mjr 77:0b96f6867312 405
mjr 35:e959ffba78fd 406 // initially configure with no LedWiz output ports
mjr 35:e959ffba78fd 407 outPort[0].typ = PortTypeDisabled;
mjr 66:2e3583fbd2f4 408
mjr 66:2e3583fbd2f4 409 // initially configure with no shift key
mjr 78:1e00b3fa11af 410 shiftButton.idx = 0;
mjr 78:1e00b3fa11af 411 shiftButton.mode = 0;
mjr 53:9b2611964afc 412
mjr 35:e959ffba78fd 413 // initially configure with no input buttons
mjr 35:e959ffba78fd 414 for (int i = 0 ; i < MAX_BUTTONS ; ++i)
mjr 53:9b2611964afc 415 button[i].set(PINNAME_TO_WIRE(NC), BtnTypeNone, 0);
mjr 38:091e511ce8a0 416
mjr 55:4db125cd11a0 417 #if STANDARD_CONFIG | TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 418 // For the standard configuration, assign 24 input ports to
mjr 55:4db125cd11a0 419 // joystick buttons 1-24. Assign the same GPIO pins used
mjr 55:4db125cd11a0 420 // in the original v1 default configuration. For expansion
mjr 55:4db125cd11a0 421 // board testing purposes, also assign the input ports, with
mjr 55:4db125cd11a0 422 // the noted differences.
mjr 38:091e511ce8a0 423 for (int i = 0 ; i < 24 ; ++i) {
mjr 55:4db125cd11a0 424 static const int bp[] = {
mjr 53:9b2611964afc 425 PINNAME_TO_WIRE(PTC2), // 1
mjr 53:9b2611964afc 426 PINNAME_TO_WIRE(PTB3), // 2
mjr 53:9b2611964afc 427 PINNAME_TO_WIRE(PTB2), // 3
mjr 53:9b2611964afc 428 PINNAME_TO_WIRE(PTB1), // 4
mjr 53:9b2611964afc 429 PINNAME_TO_WIRE(PTE30), // 5
mjr 48:058ace2aed1d 430 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 431 PINNAME_TO_WIRE(PTC11), // 6 - expansion boards use PTC11 for this, since PTE22
mjr 55:4db125cd11a0 432 // is reserved for a plunger connection
mjr 55:4db125cd11a0 433 #elif STANDARD_CONFIG
mjr 55:4db125cd11a0 434 PINNAME_TO_WIRE(PTE22), // 6 - original standalone setup uses PTE22
mjr 48:058ace2aed1d 435 #endif
mjr 53:9b2611964afc 436 PINNAME_TO_WIRE(PTE5), // 7
mjr 53:9b2611964afc 437 PINNAME_TO_WIRE(PTE4), // 8
mjr 53:9b2611964afc 438 PINNAME_TO_WIRE(PTE3), // 9
mjr 53:9b2611964afc 439 PINNAME_TO_WIRE(PTE2), // 10
mjr 53:9b2611964afc 440 PINNAME_TO_WIRE(PTB11), // 11
mjr 53:9b2611964afc 441 PINNAME_TO_WIRE(PTB10), // 12
mjr 53:9b2611964afc 442 PINNAME_TO_WIRE(PTB9), // 13
mjr 53:9b2611964afc 443 PINNAME_TO_WIRE(PTB8), // 14
mjr 53:9b2611964afc 444 PINNAME_TO_WIRE(PTC12), // 15
mjr 53:9b2611964afc 445 PINNAME_TO_WIRE(PTC13), // 16
mjr 53:9b2611964afc 446 PINNAME_TO_WIRE(PTC16), // 17
mjr 53:9b2611964afc 447 PINNAME_TO_WIRE(PTC17), // 18
mjr 53:9b2611964afc 448 PINNAME_TO_WIRE(PTA16), // 19
mjr 53:9b2611964afc 449 PINNAME_TO_WIRE(PTA17), // 20
mjr 53:9b2611964afc 450 PINNAME_TO_WIRE(PTE31), // 21
mjr 53:9b2611964afc 451 PINNAME_TO_WIRE(PTD6), // 22
mjr 53:9b2611964afc 452 PINNAME_TO_WIRE(PTD7), // 23
mjr 53:9b2611964afc 453 PINNAME_TO_WIRE(PTE1) // 24
mjr 40:cc0d9814522b 454 };
mjr 48:058ace2aed1d 455 button[i].set(bp[i],
mjr 48:058ace2aed1d 456 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 457 // For expansion board testing only, assign the inputs
mjr 55:4db125cd11a0 458 // to keyboard keys A, B, etc. This isn't useful; it's
mjr 55:4db125cd11a0 459 // just for testing purposes. Note that the USB key code
mjr 55:4db125cd11a0 460 // for "A" is 4, "B" is 5, and so on sequentially through
mjr 55:4db125cd11a0 461 // the alphabet.
mjr 55:4db125cd11a0 462 BtnTypeKey, i+4);
mjr 55:4db125cd11a0 463 #elif STANDARD_CONFIG
mjr 55:4db125cd11a0 464 // For the standard configuration, assign the input to
mjr 55:4db125cd11a0 465 // joystick buttons 1-24, as in the original v1 default
mjr 55:4db125cd11a0 466 // configuration.
mjr 55:4db125cd11a0 467 BtnTypeJoystick, i+1);
mjr 48:058ace2aed1d 468 #endif
mjr 48:058ace2aed1d 469
mjr 38:091e511ce8a0 470 }
mjr 38:091e511ce8a0 471 #endif
mjr 38:091e511ce8a0 472
mjr 55:4db125cd11a0 473 #if TEST_CONFIG_EXPAN
mjr 55:4db125cd11a0 474 // For testing purposes, configure the basic complement of
mjr 55:4db125cd11a0 475 // expansion board ports. AS MENTIONED ABOVE, THIS IS PURELY FOR
mjr 55:4db125cd11a0 476 // TESTING. DON'T USE THIS METHOD TO CONFIGURE YOUR EXPANSION
mjr 55:4db125cd11a0 477 // BOARDS FOR ACTUAL DEPLOYMENT. It's much easier and cleaner
mjr 55:4db125cd11a0 478 // to use the unmodified standard build, and customize your
mjr 55:4db125cd11a0 479 // installation with the Pinscape Config Tool on Windows.
mjr 40:cc0d9814522b 480 //
mjr 55:4db125cd11a0 481 // For this testing setup, we'll configure one main board, one
mjr 55:4db125cd11a0 482 // power board, and one chime board. The *physical* ports on
mjr 55:4db125cd11a0 483 // the board are shown below. The logical (LedWiz/DOF) numbering
mjr 55:4db125cd11a0 484 // ISN'T sequential through the physical ports, because we want
mjr 55:4db125cd11a0 485 // to arrange the DOF ports so that the most important and most
mjr 55:4db125cd11a0 486 // common toys are assigned to ports 1-32. Those ports are
mjr 55:4db125cd11a0 487 // special because they're accessible to ALL software on the PC,
mjr 55:4db125cd11a0 488 // including older LedWiz-only software such as Future Pinball.
mjr 55:4db125cd11a0 489 // Ports above 32 are accessible only to modern DOF software,
mjr 55:4db125cd11a0 490 // like Visual Pinball and PinballX.
mjr 40:cc0d9814522b 491 //
mjr 40:cc0d9814522b 492 // Main board
mjr 40:cc0d9814522b 493 // TLC ports 0-15 -> flashers
mjr 40:cc0d9814522b 494 // TLC ports 16 -> strobe
mjr 40:cc0d9814522b 495 // TLC ports 17-31 -> flippers
mjr 40:cc0d9814522b 496 // Dig GPIO PTC8 -> knocker (timer-protected outputs)
mjr 40:cc0d9814522b 497 //
mjr 40:cc0d9814522b 498 // Power board:
mjr 40:cc0d9814522b 499 // TLC ports 32-63 -> general purpose outputs
mjr 40:cc0d9814522b 500 //
mjr 40:cc0d9814522b 501 // Chime board:
mjr 40:cc0d9814522b 502 // HC595 ports 0-7 -> timer-protected outputs
mjr 40:cc0d9814522b 503 //
mjr 38:091e511ce8a0 504 {
mjr 38:091e511ce8a0 505 int n = 0;
mjr 40:cc0d9814522b 506
mjr 40:cc0d9814522b 507 // 1-15 = flashers (TLC ports 0-15)
mjr 40:cc0d9814522b 508 // 16 = strobe (TLC port 15)
mjr 40:cc0d9814522b 509 for (int i = 0 ; i < 16 ; ++i)
mjr 40:cc0d9814522b 510 outPort[n++].set(PortTypeTLC5940, i, PortFlagGamma);
mjr 40:cc0d9814522b 511
mjr 53:9b2611964afc 512 // 17 = knocker (PTC8)
mjr 53:9b2611964afc 513 outPort[n++].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC8));
mjr 35:e959ffba78fd 514
mjr 40:cc0d9814522b 515 // 18-49 = power board outputs 1-32 (TLC ports 32-63)
mjr 40:cc0d9814522b 516 for (int i = 0 ; i < 32 ; ++i)
mjr 40:cc0d9814522b 517 outPort[n++].set(PortTypeTLC5940, i+32);
mjr 40:cc0d9814522b 518
mjr 40:cc0d9814522b 519 // 50-65 = flipper RGB (TLC ports 16-31)
mjr 40:cc0d9814522b 520 for (int i = 0 ; i < 16 ; ++i)
mjr 40:cc0d9814522b 521 outPort[n++].set(PortTypeTLC5940, i+16, PortFlagGamma);
mjr 59:94eb9265b6d7 522
mjr 40:cc0d9814522b 523 // 66-73 = chime board ports 1-8 (74HC595 ports 0-7)
mjr 40:cc0d9814522b 524 for (int i = 0 ; i < 8 ; ++i)
mjr 40:cc0d9814522b 525 outPort[n++].set(PortType74HC595, i);
mjr 59:94eb9265b6d7 526
mjr 40:cc0d9814522b 527 // set Disabled to signify end of configured outputs
mjr 38:091e511ce8a0 528 outPort[n].typ = PortTypeDisabled;
mjr 38:091e511ce8a0 529 }
mjr 38:091e511ce8a0 530 #endif
mjr 48:058ace2aed1d 531
mjr 55:4db125cd11a0 532 #if STANDARD_CONFIG
mjr 55:4db125cd11a0 533 //
mjr 55:4db125cd11a0 534 // For the standard build, set up the original complement
mjr 55:4db125cd11a0 535 // of 22 ports from the v1 default onfiguration.
mjr 55:4db125cd11a0 536 //
mjr 55:4db125cd11a0 537 // IMPORTANT! As mentioned above, don't edit this file to
mjr 55:4db125cd11a0 538 // customize this for your machine. Instead, use the unmodified
mjr 55:4db125cd11a0 539 // standard build, and customize your installation using the
mjr 55:4db125cd11a0 540 // Pinscape Config Tool on Windows.
mjr 55:4db125cd11a0 541 //
mjr 48:058ace2aed1d 542 #if TEST_KEEP_PRINTF
mjr 55:4db125cd11a0 543 outPort[ 0].set(PortTypeVirtual, PINNAME_TO_WIRE(NC)); // port 1 = NC to keep debug printf (PTA1 is SDA UART)
mjr 55:4db125cd11a0 544 outPort[ 1].set(PortTypeVirtual, PINNAME_TO_WIRE(NC)); // port 2 = NC to keep debug printf (PTA2 is SDA UART)
mjr 48:058ace2aed1d 545 #else
mjr 53:9b2611964afc 546 outPort[ 0].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA1)); // port 1 = PTA1
mjr 53:9b2611964afc 547 outPort[ 1].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA2)); // port 2 = PTA2
mjr 48:058ace2aed1d 548 #endif
mjr 53:9b2611964afc 549 outPort[ 2].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD4)); // port 3 = PTD4
mjr 53:9b2611964afc 550 outPort[ 3].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA12)); // port 4 = PTA12
mjr 53:9b2611964afc 551 outPort[ 4].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA4)); // port 5 = PTA4
mjr 53:9b2611964afc 552 outPort[ 5].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA5)); // port 6 = PTA5
mjr 53:9b2611964afc 553 outPort[ 6].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTA13)); // port 7 = PTA13
mjr 53:9b2611964afc 554 outPort[ 7].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD5)); // port 8 = PTD5
mjr 53:9b2611964afc 555 outPort[ 8].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD0)); // port 9 = PTD0
mjr 53:9b2611964afc 556 outPort[ 9].set(PortTypeGPIOPWM, PINNAME_TO_WIRE(PTD3)); // port 10 = PTD3
mjr 53:9b2611964afc 557 outPort[10].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTD2)); // port 11 = PTD2
mjr 53:9b2611964afc 558 outPort[11].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC8)); // port 12 = PTC8
mjr 53:9b2611964afc 559 outPort[12].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC9)); // port 13 = PTC9
mjr 53:9b2611964afc 560 outPort[13].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC7)); // port 14 = PTC7
mjr 53:9b2611964afc 561 outPort[14].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC0)); // port 15 = PTC0
mjr 53:9b2611964afc 562 outPort[15].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC3)); // port 16 = PTC3
mjr 53:9b2611964afc 563 outPort[16].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC4)); // port 17 = PTC4
mjr 53:9b2611964afc 564 outPort[17].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC5)); // port 18 = PTC5
mjr 53:9b2611964afc 565 outPort[18].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC6)); // port 19 = PTC6
mjr 53:9b2611964afc 566 outPort[19].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC10)); // port 20 = PTC10
mjr 53:9b2611964afc 567 outPort[20].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTC11)); // port 21 = PTC11
mjr 53:9b2611964afc 568 outPort[21].set(PortTypeGPIODig, PINNAME_TO_WIRE(PTE0)); // port 22 = PTE0
mjr 48:058ace2aed1d 569 #endif
mjr 35:e959ffba78fd 570 }
mjr 35:e959ffba78fd 571
mjr 35:e959ffba78fd 572 // --- USB DEVICE CONFIGURATION ---
mjr 35:e959ffba78fd 573
mjr 35:e959ffba78fd 574 // USB device identification - vendor ID and product ID. For LedLWiz
mjr 35:e959ffba78fd 575 // emulation, use vendor ID 0xFAFA and product ID 0x00EF + unit#, where
mjr 35:e959ffba78fd 576 // unit# is the nominal LedWiz unit number from 1 to 16. Alternatively,
mjr 35:e959ffba78fd 577 // if LedWiz emulation isn't desired or causes any driver conflicts on
mjr 35:e959ffba78fd 578 // the host, we have a private Pinscape assignment as vendor ID 0x1209
mjr 35:e959ffba78fd 579 // and product ID 0xEAEA (registered with http://pid.codes, a registry
mjr 35:e959ffba78fd 580 // for open-source USB projects).
mjr 35:e959ffba78fd 581 uint16_t usbVendorID;
mjr 35:e959ffba78fd 582 uint16_t usbProductID;
mjr 35:e959ffba78fd 583
mjr 35:e959ffba78fd 584 // Pinscape Controller unit number. This is the nominal unit number,
mjr 35:e959ffba78fd 585 // from 1 to 16. We report this in the status query; DOF uses it to
mjr 53:9b2611964afc 586 // distinguish among Pinscape units. Note that this doesn't affect
mjr 35:e959ffba78fd 587 // the LedWiz unit numbering, which is implied by the USB Product ID.
mjr 35:e959ffba78fd 588 uint8_t psUnitNo;
mjr 35:e959ffba78fd 589
mjr 35:e959ffba78fd 590 // Are joystick reports enabled? Joystick reports can be turned off, to
mjr 35:e959ffba78fd 591 // use the device as purely an output controller.
mjr 77:0b96f6867312 592 uint8_t joystickEnabled;
mjr 35:e959ffba78fd 593
mjr 90:aa4e571da8e8 594 // Joystick axis report format, as a USBJoystick::AXIS_FORMAT_xxx value.
mjr 90:aa4e571da8e8 595 uint8_t joystickAxisFormat;
mjr 90:aa4e571da8e8 596
mjr 92:f264fbaa1be5 597 // Joystick report timing. This is the minimum time between joystick
mjr 92:f264fbaa1be5 598 // reports, in microseconds.
mjr 92:f264fbaa1be5 599 uint32_t jsReportInterval_us;
mjr 92:f264fbaa1be5 600
mjr 51:57eb311faafa 601 // Timeout for rebooting the KL25Z when the connection is lost. On some
mjr 51:57eb311faafa 602 // hosts, the mbed USB stack has problems reconnecting after an initial
mjr 51:57eb311faafa 603 // connection is dropped. As a workaround, we can automatically reboot
mjr 51:57eb311faafa 604 // the KL25Z when it detects that it's no longer connected, after the
mjr 51:57eb311faafa 605 // interval set here expires. The timeout is in seconds; setting this
mjr 51:57eb311faafa 606 // to 0 disables the automatic reboot.
mjr 51:57eb311faafa 607 uint8_t disconnectRebootTimeout;
mjr 35:e959ffba78fd 608
mjr 35:e959ffba78fd 609 // --- ACCELEROMETER ---
mjr 78:1e00b3fa11af 610 struct
mjr 78:1e00b3fa11af 611 {
mjr 78:1e00b3fa11af 612 // accelerometer orientation (OrientationXxx value)
mjr 78:1e00b3fa11af 613 uint8_t orientation;
mjr 35:e959ffba78fd 614
mjr 78:1e00b3fa11af 615 // dynamic range (AccelRangeXxx value)
mjr 78:1e00b3fa11af 616 uint8_t range;
mjr 77:0b96f6867312 617
mjr 78:1e00b3fa11af 618 // Auto-centering mode:
mjr 78:1e00b3fa11af 619 // 0 = auto-centering on, 5-second timer
mjr 78:1e00b3fa11af 620 // 1-60 = auto-centering on with the given timer in seconds
mjr 78:1e00b3fa11af 621 // 255 = auto-centering off
mjr 78:1e00b3fa11af 622 uint8_t autoCenterTime;
mjr 92:f264fbaa1be5 623
mjr 92:f264fbaa1be5 624 // Accelerometer report "stuttering". This is the number of times
mjr 92:f264fbaa1be5 625 // that each accelerometer reading is repeated in the joystick
mjr 92:f264fbaa1be5 626 // reports. If this is set to 1 (or 0), a new accelerometer reading
mjr 92:f264fbaa1be5 627 // is taken on every joystick report. If set to 2, a new reading
mjr 92:f264fbaa1be5 628 // is taken on every other report, and the previous reading is
mjr 92:f264fbaa1be5 629 // repeated on the alternating reports. If set to 3, we take a
mjr 92:f264fbaa1be5 630 // new reading on each third report, and so on. The purpose is
mjr 92:f264fbaa1be5 631 // to slow down accelerometer readings for the benefit of Visual
mjr 92:f264fbaa1be5 632 // Pinball, which will miss readings if taken faster than the
mjr 92:f264fbaa1be5 633 // video refresh rate, while sending joystick reports at a
mjr 92:f264fbaa1be5 634 // faster rate for lower button input latency.
mjr 92:f264fbaa1be5 635 uint8_t stutter;
mjr 78:1e00b3fa11af 636
mjr 78:1e00b3fa11af 637 } accel;
mjr 35:e959ffba78fd 638
mjr 35:e959ffba78fd 639
mjr 52:8298b2a73eb2 640 // --- EXPANSION BOARDS ---
mjr 52:8298b2a73eb2 641 struct
mjr 52:8298b2a73eb2 642 {
mjr 53:9b2611964afc 643 uint8_t typ; // expansion board set type:
mjr 115:39d2eb4b1830 644 // 0 -> Standalone KL25Z
mjr 105:6a25bbfae1e4 645 // 1 -> Pinscape Expansion Boards
mjr 105:6a25bbfae1e4 646 // 2 -> Pinscape All-In-One (AIO)
arnoz 116:7a67265d7c19 647 // 3 -> Pinscape Lite
arnoz 116:7a67265d7c19 648 // 4 -> Arnoz RigMaster
arnoz 116:7a67265d7c19 649 // 5 -> Arnoz KLShield
mjr 53:9b2611964afc 650 uint8_t vsn; // board set interface version
mjr 115:39d2eb4b1830 651 uint8_t ext[4]; // extended data - varies by board set type
mjr 52:8298b2a73eb2 652
mjr 52:8298b2a73eb2 653 } expan;
mjr 52:8298b2a73eb2 654
mjr 52:8298b2a73eb2 655
mjr 35:e959ffba78fd 656 // --- PLUNGER CONFIGURATION ---
mjr 35:e959ffba78fd 657 struct
mjr 35:e959ffba78fd 658 {
mjr 77:0b96f6867312 659 // Plunger enabled/disabled. Note that we use the status flag
mjr 77:0b96f6867312 660 // bit 0x01 if enabled, 0x00 if disabled. This conveniently
mjr 77:0b96f6867312 661 // can be tested as though it's a bool, but should always be
mjr 77:0b96f6867312 662 // stored as 0x01 or 0x00 so that it can be OR'ed into the
mjr 77:0b96f6867312 663 // status report flag bits.
mjr 77:0b96f6867312 664 uint8_t enabled;
mjr 33:d832bcab089e 665
mjr 35:e959ffba78fd 666 // plunger sensor type
mjr 77:0b96f6867312 667 uint8_t sensorType;
mjr 113:7330439f2ffc 668
mjr 113:7330439f2ffc 669 // Miscellaneous parameters; meanings defined per sensor:
mjr 113:7330439f2ffc 670 //
mjr 113:7330439f2ffc 671 // Sensor Param1
mjr 113:7330439f2ffc 672 // VCNL4010 IRED current
mjr 113:7330439f2ffc 673 //
mjr 113:7330439f2ffc 674 uint8_t param1;
mjr 35:e959ffba78fd 675
mjr 35:e959ffba78fd 676 // Plunger sensor pins. To accommodate a wide range of sensor types,
mjr 35:e959ffba78fd 677 // we keep a generic list of 4 pin assignments. The use of each pin
mjr 111:42dc75fbe623 678 // varies by sensor. The lists below are in order of the entries in
mjr 111:42dc75fbe623 679 // the sensorPin[] array, which is also the order of the pin numbers
mjr 111:42dc75fbe623 680 // passed in the USB configuration commands. "NC" means that the pin
mjr 111:42dc75fbe623 681 // isn't used by the sensor, so the slot is ignored. Each pin's GPIO
mjr 111:42dc75fbe623 682 // usage is also listed, because usages like AnalogIn and PWM mean
mjr 111:42dc75fbe623 683 // that you have to use a GPIO pin that can multiplexed to the
mjr 111:42dc75fbe623 684 // specified peripheral function. If the usage is listed as simply
mjr 111:42dc75fbe623 685 // "GPIO", it means that no special peripheral function is needed for
mjr 111:42dc75fbe623 686 // that connection, so any GPIO pin can be used.
mjr 35:e959ffba78fd 687 //
mjr 111:42dc75fbe623 688 // TSL1410R/1412S/1401CL: SI (GPIO), CLK (GPIO), AO (AnalogIn), NC
mjr 111:42dc75fbe623 689 // Potentiometer: AO (AnalogIn), NC, NC, NC
mjr 111:42dc75fbe623 690 // AEDR8300: A (InterruptIn), B (InterruptIn), NC, NC
mjr 111:42dc75fbe623 691 // AS5304: A (InterruptIn), B (InterruptIn), NC, NC
mjr 111:42dc75fbe623 692 // VL6180X: SDA (GPIO), SCL (GPIO), GPIO0/CE (GPIO), NC
mjr 111:42dc75fbe623 693 // AEAT-6012-A06: CS (GPIO), CLK (GPIO), DO (GPIO), NC
mjr 111:42dc75fbe623 694 // TCD1103GFG: fM (PWM), OS (AnalogIn), ICG (GPIO), SH (GPIO)
mjr 111:42dc75fbe623 695 // VCNL4010: SDA (GPIO), SCL (GPIO), NC, NC
mjr 53:9b2611964afc 696 //
mjr 53:9b2611964afc 697 // Note! These are stored in uint8_t WIRE format, not PinName format.
mjr 111:42dc75fbe623 698 // In other words, the values here are the byte values passed in the
mjr 111:42dc75fbe623 699 // USB protocol to represent pin numbers. You can translate these
mjr 111:42dc75fbe623 700 // byte values to PinName values using wirePinName(uint8_t).
mjr 111:42dc75fbe623 701 //
mjr 53:9b2611964afc 702 uint8_t sensorPin[4];
mjr 35:e959ffba78fd 703
mjr 82:4f6209cb5c33 704 // Automatic zeroing. If enabled, we'll reset the plunger position to
mjr 82:4f6209cb5c33 705 // the park position after a period of inactivity. This only applies
mjr 82:4f6209cb5c33 706 // to certain sensor types; sensors that don't use it simply ignore it.
mjr 82:4f6209cb5c33 707 struct
mjr 82:4f6209cb5c33 708 {
mjr 82:4f6209cb5c33 709 uint8_t flags; // flags bits - combination of PlungerAutoZeroXxx flags
mjr 82:4f6209cb5c33 710 uint8_t t; // inactivity time in seconds
mjr 82:4f6209cb5c33 711 } autoZero;
mjr 82:4f6209cb5c33 712
mjr 85:3c28aee81cde 713 // Jitter filter. This is the size of the hysteresis window, in joystick
mjr 85:3c28aee81cde 714 // units (-4095..+4095). One joystick unit is approximately 1/10000" of
mjr 85:3c28aee81cde 715 // physical travel. Zero disables the jitter filter.
mjr 85:3c28aee81cde 716 uint16_t jitterWindow;
mjr 85:3c28aee81cde 717
mjr 91:ae9be42652bf 718 // Plunger sensor reverse orientation flags. This is a bit mask:
mjr 91:ae9be42652bf 719 //
mjr 91:ae9be42652bf 720 // 0x01 = Reverse orientation enabled. We invert the plunger sensor
mjr 91:ae9be42652bf 721 // readings, as though the sensor were physically flipped
mjr 91:ae9be42652bf 722 // around. This can be used to correct for installing the
mjr 91:ae9be42652bf 723 // sensor backwards without having to change the hardware.
mjr 91:ae9be42652bf 724 //
mjr 91:ae9be42652bf 725 // 0x80 = READ-ONLY feature flag. This always reads as set if the
mjr 91:ae9be42652bf 726 // feature is enabled. Note that the USB data exchanger always
mjr 91:ae9be42652bf 727 // sets the bit on read, so it's not necessary to actually
mjr 91:ae9be42652bf 728 // store it.
mjr 91:ae9be42652bf 729 //
mjr 91:ae9be42652bf 730 uint8_t reverseOrientation;
mjr 91:ae9be42652bf 731
mjr 87:8d35c74403af 732 // bar code sensor parameters
mjr 87:8d35c74403af 733 struct
mjr 87:8d35c74403af 734 {
mjr 87:8d35c74403af 735 uint16_t startPix; // starting pixel offset
mjr 87:8d35c74403af 736 } barCode;
mjr 87:8d35c74403af 737
mjr 53:9b2611964afc 738 // ZB LAUNCH BALL button setup.
mjr 35:e959ffba78fd 739 //
mjr 35:e959ffba78fd 740 // This configures the "ZB Launch Ball" feature in DOF, based on Zeb's (of
mjr 35:e959ffba78fd 741 // zebsboards.com) scheme for using a mechanical plunger as a Launch button.
mjr 35:e959ffba78fd 742 // Set the port to 0 to disable the feature.
mjr 35:e959ffba78fd 743 //
mjr 35:e959ffba78fd 744 // The port number is an LedWiz port number that we monitor for activation.
mjr 53:9b2611964afc 745 // This port isn't meant to be connected to a physical device, although it
mjr 53:9b2611964afc 746 // can be if desired. It's primarily to let the host tell the controller
mjr 53:9b2611964afc 747 // when the ZB Launch feature is active. The port numbering starts at 1;
mjr 53:9b2611964afc 748 // set this to zero to disable the feature.
mjr 35:e959ffba78fd 749 //
mjr 53:9b2611964afc 750 // The key type and code has the same meaning as for a button mapping. This
mjr 53:9b2611964afc 751 // sets the key input sent to the PC when the plunger triggers a launch when
mjr 53:9b2611964afc 752 // the mode is active. For example, set keytype=2 and keycode=0x28 to send
mjr 53:9b2611964afc 753 // the Enter key (which is the key almost all PC pinball software uses for
mjr 53:9b2611964afc 754 // plunger and Launch button input).
mjr 35:e959ffba78fd 755 //
mjr 40:cc0d9814522b 756 // The "push distance" is the distance, in 1/1000 inch units, for registering a
mjr 40:cc0d9814522b 757 // push on the plunger as a button push. If the player pushes the plunger
mjr 40:cc0d9814522b 758 // forward of the rest position by this amount, we'll treat it as pushing the
mjr 40:cc0d9814522b 759 // button, even if the player didn't pull back the plunger first. This lets
mjr 40:cc0d9814522b 760 // the player treat the plunger knob as a button for games where it's meaningful
mjr 35:e959ffba78fd 761 // to hold down the Launch button for specific intervals (e.g., "Championship
mjr 35:e959ffba78fd 762 // Pub").
mjr 35:e959ffba78fd 763 struct
mjr 35:e959ffba78fd 764 {
mjr 53:9b2611964afc 765 uint8_t port;
mjr 53:9b2611964afc 766 uint8_t keytype;
mjr 53:9b2611964afc 767 uint8_t keycode;
mjr 53:9b2611964afc 768 uint16_t pushDistance;
mjr 35:e959ffba78fd 769
mjr 35:e959ffba78fd 770 } zbLaunchBall;
mjr 35:e959ffba78fd 771
mjr 35:e959ffba78fd 772 // --- PLUNGER CALIBRATION ---
mjr 35:e959ffba78fd 773 struct
mjr 35:e959ffba78fd 774 {
mjr 35:e959ffba78fd 775 // has the plunger been calibrated?
mjr 53:9b2611964afc 776 bool calibrated;
mjr 55:4db125cd11a0 777
mjr 55:4db125cd11a0 778 // Feature enable mask:
mjr 55:4db125cd11a0 779 //
mjr 55:4db125cd11a0 780 // 0x01 = calibration button enabled
mjr 55:4db125cd11a0 781 // 0x02 = indicator light enabled
mjr 55:4db125cd11a0 782 uint8_t features;
mjr 35:e959ffba78fd 783
mjr 35:e959ffba78fd 784 // calibration button switch pin
mjr 53:9b2611964afc 785 uint8_t btn;
mjr 35:e959ffba78fd 786
mjr 35:e959ffba78fd 787 // calibration button indicator light pin
mjr 53:9b2611964afc 788 uint8_t led;
mjr 35:e959ffba78fd 789
mjr 48:058ace2aed1d 790 // Plunger calibration min, zero, and max. These are in terms of the
mjr 48:058ace2aed1d 791 // unsigned 16-bit scale (0x0000..0xffff) that we use for the raw sensor
mjr 48:058ace2aed1d 792 // readings.
mjr 48:058ace2aed1d 793 //
mjr 48:058ace2aed1d 794 // The zero point is the rest position (aka park position), where the
mjr 48:058ace2aed1d 795 // plunger is in equilibrium between the main spring and the barrel
mjr 48:058ace2aed1d 796 // spring. In the standard setup, the plunger can travel a small
mjr 48:058ace2aed1d 797 // distance forward of the rest position, because the barrel spring
mjr 48:058ace2aed1d 798 // can be compressed a bit. The minimum is the maximum forward point
mjr 48:058ace2aed1d 799 // where the barrel spring can't be compressed any further.
mjr 48:058ace2aed1d 800 uint16_t min;
mjr 48:058ace2aed1d 801 uint16_t zero;
mjr 48:058ace2aed1d 802 uint16_t max;
mjr 52:8298b2a73eb2 803
mjr 100:1ff35c07217c 804 // Raw calibration data. Some sensors need to keep track of raw
mjr 100:1ff35c07217c 805 // sensor data for calibration, in addition to the processed
mjr 100:1ff35c07217c 806 // range information that the generic code maintains. We
mjr 100:1ff35c07217c 807 // provide three uint16 slots for the specific sensor subclass's
mjr 100:1ff35c07217c 808 // use, with the meanings defined by the subclass.
mjr 100:1ff35c07217c 809 uint16_t raw0;
mjr 100:1ff35c07217c 810 uint16_t raw1;
mjr 100:1ff35c07217c 811 uint16_t raw2;
mjr 100:1ff35c07217c 812
mjr 52:8298b2a73eb2 813 // Measured release time, in milliseconds.
mjr 52:8298b2a73eb2 814 uint8_t tRelease;
mjr 35:e959ffba78fd 815
mjr 44:b5ac89b9cd5d 816 // Reset the plunger calibration
mjr 44:b5ac89b9cd5d 817 void setDefaults()
mjr 35:e959ffba78fd 818 {
mjr 44:b5ac89b9cd5d 819 calibrated = false; // not calibrated
mjr 48:058ace2aed1d 820 min = 0; // assume we can go all the way forward...
mjr 48:058ace2aed1d 821 max = 0xffff; // ...and all the way back
mjr 48:058ace2aed1d 822 zero = max/6; // the rest position is usually around 1/2" back = 1/6 of total travel
mjr 52:8298b2a73eb2 823 tRelease = 65; // standard 65ms release time
mjr 100:1ff35c07217c 824 raw0 = raw1 = raw2 = 0; // clear the raw sensor data items
mjr 44:b5ac89b9cd5d 825 }
mjr 44:b5ac89b9cd5d 826
mjr 44:b5ac89b9cd5d 827 // Begin calibration. This sets each limit to the worst
mjr 44:b5ac89b9cd5d 828 // case point - for example, we set the retracted position
mjr 44:b5ac89b9cd5d 829 // to all the way forward. Each actual reading that comes
mjr 44:b5ac89b9cd5d 830 // in is then checked against the current limit, and if it's
mjr 44:b5ac89b9cd5d 831 // outside of the limit, we reset the limit to the new reading.
mjr 44:b5ac89b9cd5d 832 void begin()
mjr 44:b5ac89b9cd5d 833 {
mjr 48:058ace2aed1d 834 min = 0; // we don't calibrate the maximum forward position, so keep this at zero
mjr 48:058ace2aed1d 835 zero = 0xffff; // set the zero position all the way back
mjr 48:058ace2aed1d 836 max = 0; // set the retracted position all the way forward
mjr 52:8298b2a73eb2 837 tRelease = 65; // revert to a default release time
mjr 35:e959ffba78fd 838 }
mjr 17:ab3cec0c8bf4 839
mjr 35:e959ffba78fd 840 } cal;
mjr 18:5e890ebd0023 841
mjr 35:e959ffba78fd 842 } plunger;
mjr 29:582472d0bc57 843
mjr 35:e959ffba78fd 844
mjr 35:e959ffba78fd 845 // --- TV ON SWITCH ---
mjr 35:e959ffba78fd 846 //
mjr 35:e959ffba78fd 847 // To use the TV ON switch feature, the special power sensing circuitry
mjr 35:e959ffba78fd 848 // implemented on the Expansion Board must be attached (or an equivalent
mjr 35:e959ffba78fd 849 // circuit, as described in the Build Guide). The circuitry lets us
mjr 35:e959ffba78fd 850 // detect power state changes on the secondary power supply.
mjr 35:e959ffba78fd 851 struct
mjr 35:e959ffba78fd 852 {
mjr 35:e959ffba78fd 853 // PSU2 power status sense (DigitalIn pin). This pin goes LOW when the
mjr 35:e959ffba78fd 854 // secondary power supply is turned off, and remains LOW until the LATCH
mjr 35:e959ffba78fd 855 // pin is raised high AND the secondary PSU is turned on. Once HIGH,
mjr 35:e959ffba78fd 856 // it remains HIGH as long as the secondary PSU is on.
mjr 53:9b2611964afc 857 uint8_t statusPin;
mjr 35:e959ffba78fd 858
mjr 35:e959ffba78fd 859 // PSU2 power status latch (DigitalOut pin)
mjr 53:9b2611964afc 860 uint8_t latchPin;
mjr 35:e959ffba78fd 861
mjr 35:e959ffba78fd 862 // TV ON relay pin (DigitalOut pin). This pin controls the TV switch
mjr 35:e959ffba78fd 863 // relay. Raising the pin HIGH turns the relay ON (energizes the coil).
mjr 53:9b2611964afc 864 uint8_t relayPin;
mjr 35:e959ffba78fd 865
mjr 40:cc0d9814522b 866 // TV ON delay time, in 1/100 second units. This is the interval between
mjr 40:cc0d9814522b 867 // sensing that the secondary power supply has turned on and pulsing the
mjr 40:cc0d9814522b 868 // TV ON switch relay.
mjr 40:cc0d9814522b 869 int delayTime;
mjr 35:e959ffba78fd 870
mjr 35:e959ffba78fd 871 } TVON;
mjr 35:e959ffba78fd 872
mjr 53:9b2611964afc 873 // --- Night Mode ---
mjr 53:9b2611964afc 874 struct
mjr 53:9b2611964afc 875 {
mjr 55:4db125cd11a0 876 uint8_t btn; // night mode button number (1..MAX_BUTTONS, 0 = no button)
mjr 53:9b2611964afc 877 uint8_t flags; // flags:
mjr 53:9b2611964afc 878 // 0x01 = on/off switch (if not set, it's a momentary button)
mjr 55:4db125cd11a0 879 uint8_t port; // indicator output port number (1..MAX_OUT_PORTS, 0 = no indicator)
mjr 53:9b2611964afc 880 } nightMode;
mjr 53:9b2611964afc 881
mjr 29:582472d0bc57 882
mjr 35:e959ffba78fd 883 // --- TLC5940NT PWM Controller Chip Setup ---
mjr 35:e959ffba78fd 884 struct
mjr 35:e959ffba78fd 885 {
mjr 35:e959ffba78fd 886 // number of TLC5940NT chips connected in daisy chain
mjr 87:8d35c74403af 887 uint8_t nchips;
mjr 35:e959ffba78fd 888
mjr 53:9b2611964afc 889 // pin connections (wire pin IDs)
mjr 53:9b2611964afc 890 uint8_t sin; // Serial data - must connect to SPIO MOSI -> PTC6 or PTD2
mjr 53:9b2611964afc 891 uint8_t sclk; // Serial clock - must connect to SPIO SCLK -> PTC5 or PTD1
mjr 35:e959ffba78fd 892 // (but don't use PTD1, since it's hard-wired to the on-board blue LED)
mjr 53:9b2611964afc 893 uint8_t xlat; // XLAT (latch) signal - connect to any GPIO pin
mjr 53:9b2611964afc 894 uint8_t blank; // BLANK signal - connect to any GPIO pin
mjr 53:9b2611964afc 895 uint8_t gsclk; // Grayscale clock - must connect to a PWM-out capable pin
mjr 29:582472d0bc57 896
mjr 35:e959ffba78fd 897 } tlc5940;
mjr 35:e959ffba78fd 898
mjr 35:e959ffba78fd 899
mjr 35:e959ffba78fd 900 // --- 74HC595 Shift Register Setup ---
mjr 35:e959ffba78fd 901 struct
mjr 35:e959ffba78fd 902 {
mjr 35:e959ffba78fd 903 // number of 74HC595 chips attached in daisy chain
mjr 87:8d35c74403af 904 uint8_t nchips;
mjr 35:e959ffba78fd 905
mjr 35:e959ffba78fd 906 // pin connections
mjr 53:9b2611964afc 907 uint8_t sin; // Serial data - use any GPIO pin
mjr 53:9b2611964afc 908 uint8_t sclk; // Serial clock - use any GPIO pin
mjr 53:9b2611964afc 909 uint8_t latch; // Latch - use any GPIO pin
mjr 53:9b2611964afc 910 uint8_t ena; // Enable signal - use any GPIO pin
mjr 35:e959ffba78fd 911
mjr 35:e959ffba78fd 912 } hc595;
mjr 77:0b96f6867312 913
mjr 87:8d35c74403af 914 // --- TLC59116 PWM Controller Chip Setup --
mjr 87:8d35c74403af 915 struct
mjr 87:8d35c74403af 916 {
mjr 87:8d35c74403af 917 // Chip mask. Each bit represents an enabled chip at the
mjr 87:8d35c74403af 918 // corresponding 4-bit address (i.e., bit 1<<addr represents
mjr 87:8d35c74403af 919 // the chip at 'addr').
mjr 87:8d35c74403af 920 uint16_t chipMask;
mjr 87:8d35c74403af 921
mjr 87:8d35c74403af 922 // pin connections
mjr 87:8d35c74403af 923 uint8_t sda; // I2C SDA
mjr 87:8d35c74403af 924 uint8_t scl; // I2C SCL
mjr 87:8d35c74403af 925 uint8_t reset; // !RESET (hardware reset line, active low)
mjr 87:8d35c74403af 926
mjr 87:8d35c74403af 927 } tlc59116;
mjr 87:8d35c74403af 928
mjr 77:0b96f6867312 929
mjr 77:0b96f6867312 930 // --- IR Remote Control Hardware Setup ---
mjr 77:0b96f6867312 931 struct
mjr 77:0b96f6867312 932 {
mjr 77:0b96f6867312 933 // sensor (receiver) GPIO input pin; must be interrupt-capable
mjr 77:0b96f6867312 934 uint8_t sensor;
mjr 77:0b96f6867312 935
mjr 77:0b96f6867312 936 // IR emitter LED GPIO output pin; must be PWM-capable
mjr 77:0b96f6867312 937 uint8_t emitter;
mjr 77:0b96f6867312 938 } IR;
mjr 77:0b96f6867312 939
mjr 77:0b96f6867312 940
mjr 35:e959ffba78fd 941 // --- Button Input Setup ---
mjr 65:739875521aae 942 ButtonCfg button[MAX_BUTTONS + VIRTUAL_BUTTONS] __attribute__((packed));
mjr 66:2e3583fbd2f4 943
mjr 78:1e00b3fa11af 944 // Shift button. This can be used to give each physical button a
mjr 78:1e00b3fa11af 945 // second meaning.
mjr 78:1e00b3fa11af 946 struct
mjr 78:1e00b3fa11af 947 {
mjr 78:1e00b3fa11af 948 // Shift button index, 1..MAX_BUTTONS. If this is zero, there's
mjr 78:1e00b3fa11af 949 // no shift button.
mjr 78:1e00b3fa11af 950 uint8_t idx;
mjr 78:1e00b3fa11af 951
mjr 78:1e00b3fa11af 952 // Shift button mode. If the shift button has a key mapping or
mjr 78:1e00b3fa11af 953 // IR command assigned, this determines what happens when the
mjr 78:1e00b3fa11af 954 // shift button is pressed in combination with another key.
mjr 78:1e00b3fa11af 955 //
mjr 78:1e00b3fa11af 956 // 0 = Shift OR Key mode. In this mode, when you initially press
mjr 78:1e00b3fa11af 957 // the shift button, nothing happens. Instead, we wait to see if
mjr 78:1e00b3fa11af 958 // any other buttons are pressed. If so, we use the shifted meaning
mjr 78:1e00b3fa11af 959 // of the other button, and we DON'T send the shift button's key or
mjr 78:1e00b3fa11af 960 // IR command at all.
mjr 78:1e00b3fa11af 961 //
mjr 78:1e00b3fa11af 962 // 1 = Shift AND Key mode. In this mode, the shift button acts like
mjr 78:1e00b3fa11af 963 // any other button: its assigned key is sent to the PC as soon as
mjr 78:1e00b3fa11af 964 // you press it. If you also press another button while the shift
mjr 78:1e00b3fa11af 965 // button is down, the shifted meaning of the other button is used.
mjr 78:1e00b3fa11af 966 //
mjr 78:1e00b3fa11af 967 // Mode 0, the "OR" mode, is the default. This allows a button with
mjr 78:1e00b3fa11af 968 // a key assignment to do double duty as the shift button without
mjr 78:1e00b3fa11af 969 // creating any confusing situations where the shift button's own
mjr 78:1e00b3fa11af 970 // key is also sent to the PC during shift usage.
mjr 78:1e00b3fa11af 971 uint8_t mode;
mjr 78:1e00b3fa11af 972
mjr 78:1e00b3fa11af 973 } shiftButton;
mjr 17:ab3cec0c8bf4 974
mjr 35:e959ffba78fd 975 // --- LedWiz Output Port Setup ---
mjr 77:0b96f6867312 976 LedWizPortCfg outPort[MAX_OUT_PORTS] __attribute__ ((packed)); // LedWiz & extended output ports
mjr 48:058ace2aed1d 977
mjr 77:0b96f6867312 978 // --- IR Command Slots ---
mjr 77:0b96f6867312 979 IRCommandCfg IRCommand[MAX_IR_CODES] __attribute__ ((packed));
mjr 17:ab3cec0c8bf4 980 };
mjr 17:ab3cec0c8bf4 981
mjr 35:e959ffba78fd 982 #endif