Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed FastIO FastPWM USBDevice

config.h@52:8298b2a73eb2, 2016-03-05 (annotated)

Committer:
mjr
Date:
Sat Mar 05 00:16:52 2016 +0000
Revision:
52:8298b2a73eb2
Parent:
51:57eb311faafa
Child:
53:9b2611964afc
New calibration procedure - attempt #1, with separate calibration release sensingi

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mjr 17:ab3cec0c8bf4 1 // Pinscape Controller Configuration
mjr 17:ab3cec0c8bf4 2 //
mjr 35:e959ffba78fd 3 // New for 2016: dynamic configuration! To configure the controller, connect
mjr 35:e959ffba78fd 4 // the KL25Z to your PC, install the .bin file, and run the Windows config tool.
mjr 35:e959ffba78fd 5 // There's no need (as there was in the past) to edit this file or to compile a
mjr 35:e959ffba78fd 6 // custom version of the binary (.bin) to customize setup options.
mjr 35:e959ffba78fd 7 //
mjr 35:e959ffba78fd 8 // In earlier versions, configuration was largely handled with compile-time
mjr 35:e959ffba78fd 9 // constants. To customize the setup, you had to create a private forked copy
mjr 35:e959ffba78fd 10 // of the source code, edit the constants defined in config.h, and compile a
mjr 35:e959ffba78fd 11 // custom binary. That's no longer necessary!
mjr 35:e959ffba78fd 12 //
mjr 35:e959ffba78fd 13 // The new approach is to do everything (or as much as possible, anyway)
mjr 35:e959ffba78fd 14 // via the Windows config tool. You shouldn't have to recompile a custom
mjr 35:e959ffba78fd 15 // version just to make a configurable change. Of course, you're still free
mjr 35:e959ffba78fd 16 // to create a custom version if you need to add or change features in ways
mjr 35:e959ffba78fd 17 // that weren't anticipated in the original design.
mjr 35:e959ffba78fd 18 //
mjr 35:e959ffba78fd 19
mjr 48:058ace2aed1d 20 // $$$ TESTING CONFIGURATIONS
mjr 48:058ace2aed1d 21 #define TEST_CONFIG_EXPAN 0
mjr 48:058ace2aed1d 22 #define TEST_CONFIG_CAB 1
mjr 52:8298b2a73eb2 23 #define TEST_KEEP_PRINTF 0
mjr 48:058ace2aed1d 24
mjr 17:ab3cec0c8bf4 25
mjr 25:e22b88bd783a 26 #ifndef CONFIG_H
mjr 25:e22b88bd783a 27 #define CONFIG_H
mjr 17:ab3cec0c8bf4 28
mjr 33:d832bcab089e 29
mjr 35:e959ffba78fd 30 // Plunger type codes
mjr 35:e959ffba78fd 31 // NOTE! These values are part of the external USB interface. New
mjr 35:e959ffba78fd 32 // values can be added, but the meaning of an existing assigned number
mjr 35:e959ffba78fd 33 // should remain fixed to keep the PC-side config tool compatible across
mjr 35:e959ffba78fd 34 // versions.
mjr 35:e959ffba78fd 35 const int PlungerType_None = 0; // no plunger
mjr 35:e959ffba78fd 36 const int PlungerType_TSL1410RS = 1; // TSL1410R linear image sensor (1280x1 pixels, 400dpi), serial mode
mjr 35:e959ffba78fd 37 const int PlungerType_TSL1410RP = 2; // TSL1410R, parallel mode (reads the two sensor sections concurrently)
mjr 35:e959ffba78fd 38 const int PlungerType_TSL1412RS = 3; // TSL1412R linear image sensor (1536x1 pixels, 400dpi), serial mode
mjr 35:e959ffba78fd 39 const int PlungerType_TSL1412RP = 4; // TSL1412R, parallel mode
mjr 35:e959ffba78fd 40 const int PlungerType_Pot = 5; // potentionmeter
mjr 35:e959ffba78fd 41 const int PlungerType_OptQuad = 6; // AEDR8300 optical quadrature sensor
mjr 35:e959ffba78fd 42 const int PlungerType_MagQuad = 7; // AS5304 magnetic quadrature sensor
mjr 21:5048e16cc9ef 43
mjr 35:e959ffba78fd 44 // Accelerometer orientation codes
mjr 35:e959ffba78fd 45 // These values are part of the external USB interface
mjr 35:e959ffba78fd 46 const int OrientationFront = 0; // USB ports pointed toward front of cabinet
mjr 35:e959ffba78fd 47 const int OrientationLeft = 1; // ports pointed toward left side of cabinet
mjr 35:e959ffba78fd 48 const int OrientationRight = 2; // ports pointed toward right side of cabinet
mjr 35:e959ffba78fd 49 const int OrientationRear = 3; // ports pointed toward back of cabinet
mjr 25:e22b88bd783a 50
mjr 35:e959ffba78fd 51 // input button types
mjr 35:e959ffba78fd 52 const int BtnTypeJoystick = 1; // joystick button
mjr 35:e959ffba78fd 53 const int BtnTypeKey = 2; // regular keyboard key
mjr 35:e959ffba78fd 54 const int BtnTypeModKey = 3; // keyboard modifier key (shift, ctrl, etc)
mjr 35:e959ffba78fd 55 const int BtnTypeMedia = 4; // media control key (volume up/down, etc)
mjr 38:091e511ce8a0 56 const int BtnTypeSpecial = 5; // special button (night mode switch, etc)
mjr 38:091e511ce8a0 57
mjr 38:091e511ce8a0 58 // input button flags
mjr 38:091e511ce8a0 59 const uint8_t BtnFlagPulse = 0x01; // pulse mode - reports each change in the physical switch state
mjr 38:091e511ce8a0 60 // as a brief press of the logical button/keyboard key
mjr 40:cc0d9814522b 61
mjr 40:cc0d9814522b 62 // button setup structure
mjr 40:cc0d9814522b 63 struct ButtonCfg
mjr 40:cc0d9814522b 64 {
mjr 40:cc0d9814522b 65 uint8_t pin; // physical input GPIO pin - a USB-to-PinName mapping index
mjr 40:cc0d9814522b 66 uint8_t typ; // key type reported to PC - a BtnTypeXxx value
mjr 40:cc0d9814522b 67 uint8_t val; // key value reported - meaning depends on 'typ' value
mjr 40:cc0d9814522b 68 uint8_t flags; // key flags - a bitwise combination of BtnFlagXxx values
mjr 40:cc0d9814522b 69
mjr 40:cc0d9814522b 70 void set(uint8_t pin, uint8_t typ, uint8_t val, uint8_t flags = 0)
mjr 40:cc0d9814522b 71 {
mjr 40:cc0d9814522b 72 this->pin = pin;
mjr 40:cc0d9814522b 73 this->typ = typ;
mjr 40:cc0d9814522b 74 this->val = val;
mjr 40:cc0d9814522b 75 this->flags = flags;
mjr 40:cc0d9814522b 76 }
mjr 40:cc0d9814522b 77
mjr 40:cc0d9814522b 78 } __attribute__((packed));
mjr 40:cc0d9814522b 79
mjr 33:d832bcab089e 80
mjr 35:e959ffba78fd 81 // maximum number of input button mappings
mjr 35:e959ffba78fd 82 const int MAX_BUTTONS = 32;
mjr 33:d832bcab089e 83
mjr 35:e959ffba78fd 84 // LedWiz output port type codes
mjr 35:e959ffba78fd 85 // These values are part of the external USB interface
mjr 35:e959ffba78fd 86 const int PortTypeDisabled = 0; // port is disabled - not visible to LedWiz/DOF host
mjr 35:e959ffba78fd 87 const int PortTypeGPIOPWM = 1; // GPIO port, PWM enabled
mjr 35:e959ffba78fd 88 const int PortTypeGPIODig = 2; // GPIO port, digital out
mjr 35:e959ffba78fd 89 const int PortTypeTLC5940 = 3; // TLC5940 port
mjr 35:e959ffba78fd 90 const int PortType74HC595 = 4; // 74HC595 port
mjr 35:e959ffba78fd 91 const int PortTypeVirtual = 5; // Virtual port - visible to host software, but not connected to a physical output
mjr 17:ab3cec0c8bf4 92
mjr 35:e959ffba78fd 93 // LedWiz output port flag bits
mjr 38:091e511ce8a0 94 const uint8_t PortFlagActiveLow = 0x01; // physical output is active-low
mjr 38:091e511ce8a0 95 const uint8_t PortFlagNoisemaker = 0x02; // noisemaker device - disable when night mode is engaged
mjr 40:cc0d9814522b 96 const uint8_t PortFlagGamma = 0x04; // apply gamma correction to this output
mjr 35:e959ffba78fd 97
mjr 35:e959ffba78fd 98 // maximum number of output ports
mjr 48:058ace2aed1d 99 const int MAX_OUT_PORTS = 128;
mjr 33:d832bcab089e 100
mjr 38:091e511ce8a0 101 // port configuration data
mjr 38:091e511ce8a0 102 struct LedWizPortCfg
mjr 38:091e511ce8a0 103 {
mjr 38:091e511ce8a0 104 uint8_t typ; // port type: a PortTypeXxx value
mjr 38:091e511ce8a0 105 uint8_t pin; // physical output pin: for a GPIO port, this is an index in the
mjr 38:091e511ce8a0 106 // USB-to-PinName mapping list; for a TLC5940 or 74HC595 port, it's
mjr 38:091e511ce8a0 107 // the output number, starting from 0 for OUT0 on the first chip in
mjr 38:091e511ce8a0 108 // the daisy chain. For inactive and virtual ports, it's unused.
mjr 38:091e511ce8a0 109 uint8_t flags; // flags: a combination of PortFlagXxx values
mjr 40:cc0d9814522b 110
mjr 40:cc0d9814522b 111 void set(uint8_t typ, uint8_t pin, uint8_t flags = 0)
mjr 40:cc0d9814522b 112 {
mjr 40:cc0d9814522b 113 this->typ = typ;
mjr 40:cc0d9814522b 114 this->pin = pin;
mjr 40:cc0d9814522b 115 this->flags = flags;
mjr 40:cc0d9814522b 116 }
mjr 40:cc0d9814522b 117
mjr 38:091e511ce8a0 118 } __attribute__((packed));
mjr 38:091e511ce8a0 119
mjr 38:091e511ce8a0 120
mjr 35:e959ffba78fd 121 struct Config
mjr 35:e959ffba78fd 122 {
mjr 35:e959ffba78fd 123 // set all values to factory defaults
mjr 35:e959ffba78fd 124 void setFactoryDefaults()
mjr 35:e959ffba78fd 125 {
mjr 35:e959ffba78fd 126 // By default, pretend to be LedWiz unit #8. This can be from 1 to 16. Real
mjr 35:e959ffba78fd 127 // LedWiz units have their unit number set at the factory, and the vast majority
mjr 35:e959ffba78fd 128 // are set up as unit #1, since that's the default for anyone who doesn't ask
mjr 35:e959ffba78fd 129 // for a different setting. It seems rare for anyone to use more than one unit
mjr 35:e959ffba78fd 130 // in a pin cab, but for the few who do, the others will probably be numbered
mjr 35:e959ffba78fd 131 // sequentially as #2, #3, etc. It seems safe to assume that no one out there
mjr 48:058ace2aed1d 132 // has a unit #8, so we'll use that as our default. This can be changed from
mjr 48:058ace2aed1d 133 // the config tool, but for the sake of convenience, it's better to pick a
mjr 48:058ace2aed1d 134 // default that most people won't have to change.
mjr 35:e959ffba78fd 135 usbVendorID = 0xFAFA; // LedWiz vendor code
mjr 48:058ace2aed1d 136 usbProductID = 0x00F7; // LedWiz product code for unit #8
mjr 35:e959ffba78fd 137 psUnitNo = 8;
mjr 35:e959ffba78fd 138
mjr 51:57eb311faafa 139 // set a disconnect reboot timeout of 10 seconds by default
mjr 51:57eb311faafa 140 disconnectRebootTimeout = 10;
mjr 51:57eb311faafa 141
mjr 35:e959ffba78fd 142 // enable joystick reports
mjr 35:e959ffba78fd 143 joystickEnabled = true;
mjr 35:e959ffba78fd 144
mjr 35:e959ffba78fd 145 // assume standard orientation, with USB ports toward front of cabinet
mjr 35:e959ffba78fd 146 orientation = OrientationFront;
mjr 25:e22b88bd783a 147
mjr 52:8298b2a73eb2 148 // assume a basic setup with no expansion boards
mjr 52:8298b2a73eb2 149 expan.nMain = 0;
mjr 52:8298b2a73eb2 150 expan.nPower = 0;
mjr 52:8298b2a73eb2 151 expan.nChime = 0;
mjr 52:8298b2a73eb2 152
mjr 35:e959ffba78fd 153 // assume no plunger is attached
mjr 35:e959ffba78fd 154 plunger.enabled = false;
mjr 35:e959ffba78fd 155 plunger.sensorType = PlungerType_None;
mjr 35:e959ffba78fd 156
mjr 48:058ace2aed1d 157 #if TEST_CONFIG_EXPAN || TEST_CONFIG_CAB // $$$
mjr 43:7a6364d82a41 158 plunger.enabled = true;
mjr 43:7a6364d82a41 159 plunger.sensorType = PlungerType_TSL1410RS;
mjr 43:7a6364d82a41 160 plunger.sensorPin[0] = PTE20; // SI
mjr 43:7a6364d82a41 161 plunger.sensorPin[1] = PTE21; // SCLK
mjr 43:7a6364d82a41 162 plunger.sensorPin[2] = PTB0; // AO1 = PTB0 = ADC0_SE8
mjr 43:7a6364d82a41 163 plunger.sensorPin[3] = PTE22; // AO2 (parallel mode) = PTE22 = ADC0_SE3
mjr 43:7a6364d82a41 164 #endif
mjr 43:7a6364d82a41 165
mjr 48:058ace2aed1d 166 // default plunger calibration button settings
mjr 48:058ace2aed1d 167 plunger.cal.btn = PTE29;
mjr 48:058ace2aed1d 168 plunger.cal.led = PTE23;
mjr 35:e959ffba78fd 169
mjr 44:b5ac89b9cd5d 170 // set the default plunger calibration
mjr 44:b5ac89b9cd5d 171 plunger.cal.setDefaults();
mjr 35:e959ffba78fd 172
mjr 35:e959ffba78fd 173 // disable the ZB Launch Ball by default
mjr 35:e959ffba78fd 174 plunger.zbLaunchBall.port = 0;
mjr 35:e959ffba78fd 175 plunger.zbLaunchBall.btn = 0;
mjr 35:e959ffba78fd 176
mjr 35:e959ffba78fd 177 // assume no TV ON switch
mjr 43:7a6364d82a41 178 TVON.statusPin = NC;
mjr 43:7a6364d82a41 179 TVON.latchPin = NC;
mjr 43:7a6364d82a41 180 TVON.relayPin = NC;
mjr 43:7a6364d82a41 181 TVON.delayTime = 7;
mjr 48:058ace2aed1d 182 #if TEST_CONFIG_EXPAN //$$$
mjr 38:091e511ce8a0 183 TVON.statusPin = PTD2;
mjr 38:091e511ce8a0 184 TVON.latchPin = PTE0;
mjr 38:091e511ce8a0 185 TVON.relayPin = PTD3;
mjr 38:091e511ce8a0 186 TVON.delayTime = 7;
mjr 38:091e511ce8a0 187 #endif
mjr 35:e959ffba78fd 188
mjr 35:e959ffba78fd 189 // assume no TLC5940 chips
mjr 35:e959ffba78fd 190 tlc5940.nchips = 0;
mjr 48:058ace2aed1d 191 #if TEST_CONFIG_EXPAN // $$$
mjr 48:058ace2aed1d 192 tlc5940.nchips = 4;
mjr 38:091e511ce8a0 193 #endif
mjr 38:091e511ce8a0 194
mjr 38:091e511ce8a0 195 // default TLC5940 pin assignments
mjr 38:091e511ce8a0 196 tlc5940.sin = PTC6;
mjr 38:091e511ce8a0 197 tlc5940.sclk = PTC5;
mjr 38:091e511ce8a0 198 tlc5940.xlat = PTC10;
mjr 38:091e511ce8a0 199 tlc5940.blank = PTC7;
mjr 38:091e511ce8a0 200 tlc5940.gsclk = PTA1;
mjr 35:e959ffba78fd 201
mjr 35:e959ffba78fd 202 // assume no 74HC595 chips
mjr 35:e959ffba78fd 203 hc595.nchips = 0;
mjr 48:058ace2aed1d 204 #if TEST_CONFIG_EXPAN // $$$
mjr 48:058ace2aed1d 205 hc595.nchips = 1;
mjr 40:cc0d9814522b 206 #endif
mjr 40:cc0d9814522b 207
mjr 38:091e511ce8a0 208 // default 74HC595 pin assignments
mjr 38:091e511ce8a0 209 hc595.sin = PTA5;
mjr 38:091e511ce8a0 210 hc595.sclk = PTA4;
mjr 38:091e511ce8a0 211 hc595.latch = PTA12;
mjr 38:091e511ce8a0 212 hc595.ena = PTD4;
mjr 38:091e511ce8a0 213
mjr 35:e959ffba78fd 214 // initially configure with no LedWiz output ports
mjr 35:e959ffba78fd 215 outPort[0].typ = PortTypeDisabled;
mjr 38:091e511ce8a0 216 for (int i = 0 ; i < sizeof(specialPort)/sizeof(specialPort[0]) ; ++i)
mjr 38:091e511ce8a0 217 specialPort[i].typ = PortTypeDisabled;
mjr 35:e959ffba78fd 218
mjr 35:e959ffba78fd 219 // initially configure with no input buttons
mjr 35:e959ffba78fd 220 for (int i = 0 ; i < MAX_BUTTONS ; ++i)
mjr 35:e959ffba78fd 221 button[i].pin = 0; // 0 == index of NC in USB-to-PinName mapping
mjr 38:091e511ce8a0 222
mjr 48:058ace2aed1d 223 #if TEST_CONFIG_EXPAN | TEST_CONFIG_CAB
mjr 38:091e511ce8a0 224 for (int i = 0 ; i < 24 ; ++i) {
mjr 38:091e511ce8a0 225 static int bp[] = {
mjr 38:091e511ce8a0 226 21, // 1 = PTC2
mjr 38:091e511ce8a0 227 12, // 2 = PTB3
mjr 38:091e511ce8a0 228 11, // 3 = PTB2
mjr 38:091e511ce8a0 229 10, // 4 = PTB1
mjr 38:091e511ce8a0 230 54, // 5 = PTE30
mjr 48:058ace2aed1d 231 #if TEST_CONFIG_EXPAN
mjr 38:091e511ce8a0 232 30, // 6 = PTC11
mjr 48:058ace2aed1d 233 #elif TEST_CONFIG_CAG
mjr 48:058ace2aed1d 234 51, // 6 = PTE22
mjr 48:058ace2aed1d 235 #endif
mjr 38:091e511ce8a0 236 48, // 7 = PTE5
mjr 38:091e511ce8a0 237 47, // 8 = PTE4
mjr 38:091e511ce8a0 238 46, // 9 = PTE3
mjr 38:091e511ce8a0 239 45, // 10 = PTE2
mjr 38:091e511ce8a0 240 16, // 11 = PTB11
mjr 38:091e511ce8a0 241 15, // 12 = PTB10
mjr 38:091e511ce8a0 242 14, // 13 = PTB9
mjr 38:091e511ce8a0 243 13, // 14 = PTB8
mjr 38:091e511ce8a0 244 31, // 15 = PTC12
mjr 38:091e511ce8a0 245 32, // 16 = PTC13
mjr 38:091e511ce8a0 246 33, // 17 = PTC16
mjr 38:091e511ce8a0 247 34, // 18 = PTC17
mjr 38:091e511ce8a0 248 7, // 19 = PTA16
mjr 38:091e511ce8a0 249 8, // 20 = PTA17
mjr 38:091e511ce8a0 250 55, // 21 = PTE31
mjr 38:091e511ce8a0 251 41, // 22 = PTD6
mjr 38:091e511ce8a0 252 42, // 23 = PTD7
mjr 38:091e511ce8a0 253 44 // 24 = PTE1
mjr 40:cc0d9814522b 254 };
mjr 48:058ace2aed1d 255 button[i].set(bp[i],
mjr 48:058ace2aed1d 256 #if TEST_CONFIG_EXPAN
mjr 48:058ace2aed1d 257 BtnTypeKey, i+4); // keyboard key A, B, C...
mjr 48:058ace2aed1d 258 #elif TEST_CONFIG_CAB
mjr 48:058ace2aed1d 259 BtnTypeJoystick, i); // joystick button 0, 1, ...
mjr 48:058ace2aed1d 260 #endif
mjr 48:058ace2aed1d 261
mjr 38:091e511ce8a0 262 }
mjr 38:091e511ce8a0 263 #endif
mjr 38:091e511ce8a0 264
mjr 38:091e511ce8a0 265 #if 0
mjr 38:091e511ce8a0 266 button[23].typ = BtnTypeJoystick;
mjr 38:091e511ce8a0 267 button[23].val = 5; // B
mjr 38:091e511ce8a0 268 button[23].flags = 0x01; // pulse button
mjr 38:091e511ce8a0 269
mjr 38:091e511ce8a0 270 button[22].typ = BtnTypeModKey;
mjr 38:091e511ce8a0 271 button[22].val = 0x02; // left shift
mjr 38:091e511ce8a0 272
mjr 38:091e511ce8a0 273 button[21].typ = BtnTypeMedia;
mjr 38:091e511ce8a0 274 button[21].val = 0x02; // vol down
mjr 38:091e511ce8a0 275
mjr 38:091e511ce8a0 276 button[20].typ = BtnTypeMedia;
mjr 38:091e511ce8a0 277 button[20].val = 0x01; // vol up
mjr 39:b3815a1c3802 278
mjr 38:091e511ce8a0 279 #endif
mjr 38:091e511ce8a0 280
mjr 43:7a6364d82a41 281
mjr 48:058ace2aed1d 282 #if TEST_CONFIG_EXPAN // $$$
mjr 40:cc0d9814522b 283 // CONFIGURE EXPANSION BOARD PORTS
mjr 40:cc0d9814522b 284 //
mjr 40:cc0d9814522b 285 // We have the following hardware attached:
mjr 40:cc0d9814522b 286 //
mjr 40:cc0d9814522b 287 // Main board
mjr 40:cc0d9814522b 288 // TLC ports 0-15 -> flashers
mjr 40:cc0d9814522b 289 // TLC ports 16 -> strobe
mjr 40:cc0d9814522b 290 // TLC ports 17-31 -> flippers
mjr 40:cc0d9814522b 291 // Dig GPIO PTC8 -> knocker (timer-protected outputs)
mjr 40:cc0d9814522b 292 //
mjr 40:cc0d9814522b 293 // Power board:
mjr 40:cc0d9814522b 294 // TLC ports 32-63 -> general purpose outputs
mjr 40:cc0d9814522b 295 //
mjr 40:cc0d9814522b 296 // Chime board:
mjr 40:cc0d9814522b 297 // HC595 ports 0-7 -> timer-protected outputs
mjr 40:cc0d9814522b 298 //
mjr 38:091e511ce8a0 299 {
mjr 38:091e511ce8a0 300 int n = 0;
mjr 40:cc0d9814522b 301
mjr 40:cc0d9814522b 302 // 1-15 = flashers (TLC ports 0-15)
mjr 40:cc0d9814522b 303 // 16 = strobe (TLC port 15)
mjr 40:cc0d9814522b 304 for (int i = 0 ; i < 16 ; ++i)
mjr 40:cc0d9814522b 305 outPort[n++].set(PortTypeTLC5940, i, PortFlagGamma);
mjr 40:cc0d9814522b 306
mjr 40:cc0d9814522b 307 // 17 = knocker
mjr 40:cc0d9814522b 308 outPort[n++].set(PortTypeGPIODig, 27);
mjr 35:e959ffba78fd 309
mjr 40:cc0d9814522b 310 // 18-49 = power board outputs 1-32 (TLC ports 32-63)
mjr 40:cc0d9814522b 311 for (int i = 0 ; i < 32 ; ++i)
mjr 40:cc0d9814522b 312 outPort[n++].set(PortTypeTLC5940, i+32);
mjr 40:cc0d9814522b 313
mjr 40:cc0d9814522b 314 // 50-65 = flipper RGB (TLC ports 16-31)
mjr 40:cc0d9814522b 315 for (int i = 0 ; i < 16 ; ++i)
mjr 40:cc0d9814522b 316 outPort[n++].set(PortTypeTLC5940, i+16, PortFlagGamma);
mjr 40:cc0d9814522b 317
mjr 40:cc0d9814522b 318 // 66-73 = chime board ports 1-8 (74HC595 ports 0-7)
mjr 40:cc0d9814522b 319 for (int i = 0 ; i < 8 ; ++i)
mjr 40:cc0d9814522b 320 outPort[n++].set(PortType74HC595, i);
mjr 40:cc0d9814522b 321
mjr 40:cc0d9814522b 322 // set Disabled to signify end of configured outputs
mjr 38:091e511ce8a0 323 outPort[n].typ = PortTypeDisabled;
mjr 38:091e511ce8a0 324 }
mjr 38:091e511ce8a0 325 #endif
mjr 48:058ace2aed1d 326
mjr 48:058ace2aed1d 327 #if TEST_CONFIG_CAB
mjr 48:058ace2aed1d 328 #if TEST_KEEP_PRINTF
mjr 48:058ace2aed1d 329 outPort[ 0].set(PortTypeGPIOPWM, 0); // port 1 = PTA1 -> NC to keep debug printf
mjr 48:058ace2aed1d 330 outPort[ 1].set(PortTypeGPIOPWM, 0); // port 2 = PTA2 -> NC to keep debug printf
mjr 48:058ace2aed1d 331 #else
mjr 48:058ace2aed1d 332 outPort[ 0].set(PortTypeGPIOPWM, 1); // port 1 = PTA1
mjr 48:058ace2aed1d 333 outPort[ 1].set(PortTypeGPIOPWM, 2); // port 2 = PTA2
mjr 48:058ace2aed1d 334 #endif
mjr 48:058ace2aed1d 335 outPort[ 2].set(PortTypeGPIOPWM, 39); // port 3 = PTD4
mjr 48:058ace2aed1d 336 outPort[ 3].set(PortTypeGPIOPWM, 5); // port 4 = PTA12
mjr 48:058ace2aed1d 337 outPort[ 4].set(PortTypeGPIOPWM, 3); // port 5 = PTA4
mjr 48:058ace2aed1d 338 outPort[ 5].set(PortTypeGPIOPWM, 4); // port 6 = PTA5
mjr 48:058ace2aed1d 339 outPort[ 6].set(PortTypeGPIOPWM, 6); // port 7 = PTA13
mjr 48:058ace2aed1d 340 outPort[ 7].set(PortTypeGPIOPWM, 40); // port 8 = PTD5
mjr 48:058ace2aed1d 341 outPort[ 8].set(PortTypeGPIOPWM, 35); // port 9 = PTD0
mjr 48:058ace2aed1d 342 outPort[ 9].set(PortTypeGPIOPWM, 38); // port 10 = PTD3
mjr 48:058ace2aed1d 343 outPort[10].set(PortTypeGPIODig, 37); // port 11 = PTD2
mjr 48:058ace2aed1d 344 outPort[11].set(PortTypeGPIODig, 27); // port 12 = PCT8
mjr 48:058ace2aed1d 345 outPort[12].set(PortTypeGPIODig, 28); // port 13 = PCT9
mjr 48:058ace2aed1d 346 outPort[13].set(PortTypeGPIODig, 26); // port 14 = PTC7
mjr 48:058ace2aed1d 347 outPort[14].set(PortTypeGPIODig, 19); // port 15 = PTC0
mjr 48:058ace2aed1d 348 outPort[15].set(PortTypeGPIODig, 22); // port 16 = PTC3
mjr 48:058ace2aed1d 349 outPort[16].set(PortTypeGPIODig, 23); // port 17 = PTC4
mjr 48:058ace2aed1d 350 outPort[17].set(PortTypeGPIODig, 24); // port 18 = PTC5
mjr 48:058ace2aed1d 351 outPort[18].set(PortTypeGPIODig, 25); // port 19 = PTC6
mjr 48:058ace2aed1d 352 outPort[19].set(PortTypeGPIODig, 29); // port 20 = PTC10
mjr 48:058ace2aed1d 353 outPort[20].set(PortTypeGPIODig, 30); // port 21 = PTC11
mjr 48:058ace2aed1d 354 outPort[21].set(PortTypeGPIODig, 43); // port 22 = PTE0
mjr 48:058ace2aed1d 355 #endif
mjr 48:058ace2aed1d 356
mjr 38:091e511ce8a0 357 #if 0
mjr 40:cc0d9814522b 358 // configure the on-board RGB LED as outputs 1,2,3
mjr 40:cc0d9814522b 359 outPort[0].set(PortTypeGPIOPWM, 17, PortFlagActiveLow); // PTB18 = LED1 = Red LED
mjr 40:cc0d9814522b 360 outPort[1].set(PortTypeGPIOPWM, 18, PortFlagActiveLow); // PTB19 = LED2 = Green LED
mjr 40:cc0d9814522b 361 outPort[2].set(PortTypeGPIOPWM, 36, PortFlagActiveLow); // PTD1 = LED3 = Blue LED
mjr 38:091e511ce8a0 362 outPort[3].typ = PortTypeDisabled;
mjr 38:091e511ce8a0 363 #endif
mjr 35:e959ffba78fd 364 }
mjr 35:e959ffba78fd 365
mjr 35:e959ffba78fd 366 // --- USB DEVICE CONFIGURATION ---
mjr 35:e959ffba78fd 367
mjr 35:e959ffba78fd 368 // USB device identification - vendor ID and product ID. For LedLWiz
mjr 35:e959ffba78fd 369 // emulation, use vendor ID 0xFAFA and product ID 0x00EF + unit#, where
mjr 35:e959ffba78fd 370 // unit# is the nominal LedWiz unit number from 1 to 16. Alternatively,
mjr 35:e959ffba78fd 371 // if LedWiz emulation isn't desired or causes any driver conflicts on
mjr 35:e959ffba78fd 372 // the host, we have a private Pinscape assignment as vendor ID 0x1209
mjr 35:e959ffba78fd 373 // and product ID 0xEAEA (registered with http://pid.codes, a registry
mjr 35:e959ffba78fd 374 // for open-source USB projects).
mjr 35:e959ffba78fd 375 uint16_t usbVendorID;
mjr 35:e959ffba78fd 376 uint16_t usbProductID;
mjr 35:e959ffba78fd 377
mjr 35:e959ffba78fd 378 // Pinscape Controller unit number. This is the nominal unit number,
mjr 35:e959ffba78fd 379 // from 1 to 16. We report this in the status query; DOF uses it to
mjr 35:e959ffba78fd 380 // distinguish multiple Pinscape units. Note that this doesn't affect
mjr 35:e959ffba78fd 381 // the LedWiz unit numbering, which is implied by the USB Product ID.
mjr 35:e959ffba78fd 382 uint8_t psUnitNo;
mjr 35:e959ffba78fd 383
mjr 35:e959ffba78fd 384 // Are joystick reports enabled? Joystick reports can be turned off, to
mjr 35:e959ffba78fd 385 // use the device as purely an output controller.
mjr 35:e959ffba78fd 386 char joystickEnabled;
mjr 35:e959ffba78fd 387
mjr 51:57eb311faafa 388 // Timeout for rebooting the KL25Z when the connection is lost. On some
mjr 51:57eb311faafa 389 // hosts, the mbed USB stack has problems reconnecting after an initial
mjr 51:57eb311faafa 390 // connection is dropped. As a workaround, we can automatically reboot
mjr 51:57eb311faafa 391 // the KL25Z when it detects that it's no longer connected, after the
mjr 51:57eb311faafa 392 // interval set here expires. The timeout is in seconds; setting this
mjr 51:57eb311faafa 393 // to 0 disables the automatic reboot.
mjr 51:57eb311faafa 394 uint8_t disconnectRebootTimeout;
mjr 35:e959ffba78fd 395
mjr 35:e959ffba78fd 396 // --- ACCELEROMETER ---
mjr 35:e959ffba78fd 397
mjr 35:e959ffba78fd 398 // accelerometer orientation (ORIENTATION_xxx value)
mjr 35:e959ffba78fd 399 char orientation;
mjr 35:e959ffba78fd 400
mjr 35:e959ffba78fd 401
mjr 52:8298b2a73eb2 402 // --- EXPANSION BOARDS ---
mjr 52:8298b2a73eb2 403 struct
mjr 52:8298b2a73eb2 404 {
mjr 52:8298b2a73eb2 405 int nMain; // number of main interface boards (usually 1 max)
mjr 52:8298b2a73eb2 406 int nPower; // number of MOSFET power boards
mjr 52:8298b2a73eb2 407 int nChime; // number of chime boards
mjr 52:8298b2a73eb2 408
mjr 52:8298b2a73eb2 409 } expan;
mjr 52:8298b2a73eb2 410
mjr 52:8298b2a73eb2 411
mjr 35:e959ffba78fd 412 // --- PLUNGER CONFIGURATION ---
mjr 35:e959ffba78fd 413 struct
mjr 35:e959ffba78fd 414 {
mjr 35:e959ffba78fd 415 // plunger enabled/disabled
mjr 35:e959ffba78fd 416 char enabled;
mjr 33:d832bcab089e 417
mjr 35:e959ffba78fd 418 // plunger sensor type
mjr 35:e959ffba78fd 419 char sensorType;
mjr 35:e959ffba78fd 420
mjr 35:e959ffba78fd 421 // Plunger sensor pins. To accommodate a wide range of sensor types,
mjr 35:e959ffba78fd 422 // we keep a generic list of 4 pin assignments. The use of each pin
mjr 35:e959ffba78fd 423 // varies by sensor. The lists below are in order of the generic
mjr 35:e959ffba78fd 424 // pins; NC means that the pin isn't used by the sensor. Each pin's
mjr 35:e959ffba78fd 425 // GPIO usage is also listed. Certain usages limit which physical
mjr 35:e959ffba78fd 426 // pins can be assigned (e.g., AnalogIn or PwmOut).
mjr 35:e959ffba78fd 427 //
mjr 35:e959ffba78fd 428 // TSL1410R/1412R, serial: SI (DigitalOut), CLK (DigitalOut), AO (AnalogIn), NC
mjr 35:e959ffba78fd 429 // TSL1410R/1412R, parallel: SI (DigitalOut), CLK (DigitalOut), AO1 (AnalogIn), AO2 (AnalogIn)
mjr 35:e959ffba78fd 430 // Potentiometer: AO (AnalogIn), NC, NC, NC
mjr 35:e959ffba78fd 431 // AEDR8300: A (InterruptIn), B (InterruptIn), NC, NC
mjr 35:e959ffba78fd 432 // AS5304: A (InterruptIn), B (InterruptIn), NC, NC
mjr 35:e959ffba78fd 433 PinName sensorPin[4];
mjr 35:e959ffba78fd 434
mjr 35:e959ffba78fd 435 // Pseudo LAUNCH BALL button.
mjr 35:e959ffba78fd 436 //
mjr 35:e959ffba78fd 437 // This configures the "ZB Launch Ball" feature in DOF, based on Zeb's (of
mjr 35:e959ffba78fd 438 // zebsboards.com) scheme for using a mechanical plunger as a Launch button.
mjr 35:e959ffba78fd 439 // Set the port to 0 to disable the feature.
mjr 35:e959ffba78fd 440 //
mjr 35:e959ffba78fd 441 // The port number is an LedWiz port number that we monitor for activation.
mjr 35:e959ffba78fd 442 // This port isn't connected to a physical device; rather, the host turns it
mjr 35:e959ffba78fd 443 // on to indicate that the pseudo Launch button mode is in effect.
mjr 35:e959ffba78fd 444 //
mjr 35:e959ffba78fd 445 // The button number gives the button that we "press" when a launch occurs.
mjr 35:e959ffba78fd 446 // This can be connected to the physical Launch button, or can simply be
mjr 35:e959ffba78fd 447 // an otherwise unused button.
mjr 35:e959ffba78fd 448 //
mjr 40:cc0d9814522b 449 // The "push distance" is the distance, in 1/1000 inch units, for registering a
mjr 40:cc0d9814522b 450 // push on the plunger as a button push. If the player pushes the plunger
mjr 40:cc0d9814522b 451 // forward of the rest position by this amount, we'll treat it as pushing the
mjr 40:cc0d9814522b 452 // button, even if the player didn't pull back the plunger first. This lets
mjr 40:cc0d9814522b 453 // the player treat the plunger knob as a button for games where it's meaningful
mjr 35:e959ffba78fd 454 // to hold down the Launch button for specific intervals (e.g., "Championship
mjr 35:e959ffba78fd 455 // Pub").
mjr 35:e959ffba78fd 456 struct
mjr 35:e959ffba78fd 457 {
mjr 35:e959ffba78fd 458 int port;
mjr 35:e959ffba78fd 459 int btn;
mjr 40:cc0d9814522b 460 int pushDistance;
mjr 35:e959ffba78fd 461
mjr 35:e959ffba78fd 462 } zbLaunchBall;
mjr 35:e959ffba78fd 463
mjr 35:e959ffba78fd 464 // --- PLUNGER CALIBRATION ---
mjr 35:e959ffba78fd 465 struct
mjr 35:e959ffba78fd 466 {
mjr 35:e959ffba78fd 467 // has the plunger been calibrated?
mjr 35:e959ffba78fd 468 int calibrated;
mjr 35:e959ffba78fd 469
mjr 35:e959ffba78fd 470 // calibration button switch pin
mjr 35:e959ffba78fd 471 PinName btn;
mjr 35:e959ffba78fd 472
mjr 35:e959ffba78fd 473 // calibration button indicator light pin
mjr 35:e959ffba78fd 474 PinName led;
mjr 35:e959ffba78fd 475
mjr 48:058ace2aed1d 476 // Plunger calibration min, zero, and max. These are in terms of the
mjr 48:058ace2aed1d 477 // unsigned 16-bit scale (0x0000..0xffff) that we use for the raw sensor
mjr 48:058ace2aed1d 478 // readings.
mjr 48:058ace2aed1d 479 //
mjr 48:058ace2aed1d 480 // The zero point is the rest position (aka park position), where the
mjr 48:058ace2aed1d 481 // plunger is in equilibrium between the main spring and the barrel
mjr 48:058ace2aed1d 482 // spring. In the standard setup, the plunger can travel a small
mjr 48:058ace2aed1d 483 // distance forward of the rest position, because the barrel spring
mjr 48:058ace2aed1d 484 // can be compressed a bit. The minimum is the maximum forward point
mjr 48:058ace2aed1d 485 // where the barrel spring can't be compressed any further.
mjr 48:058ace2aed1d 486 uint16_t min;
mjr 48:058ace2aed1d 487 uint16_t zero;
mjr 48:058ace2aed1d 488 uint16_t max;
mjr 52:8298b2a73eb2 489
mjr 52:8298b2a73eb2 490 // Measured release time, in milliseconds.
mjr 52:8298b2a73eb2 491 uint8_t tRelease;
mjr 35:e959ffba78fd 492
mjr 44:b5ac89b9cd5d 493 // Reset the plunger calibration
mjr 44:b5ac89b9cd5d 494 void setDefaults()
mjr 35:e959ffba78fd 495 {
mjr 44:b5ac89b9cd5d 496 calibrated = false; // not calibrated
mjr 48:058ace2aed1d 497 min = 0; // assume we can go all the way forward...
mjr 48:058ace2aed1d 498 max = 0xffff; // ...and all the way back
mjr 48:058ace2aed1d 499 zero = max/6; // the rest position is usually around 1/2" back = 1/6 of total travel
mjr 52:8298b2a73eb2 500 tRelease = 65; // standard 65ms release time
mjr 44:b5ac89b9cd5d 501 }
mjr 44:b5ac89b9cd5d 502
mjr 44:b5ac89b9cd5d 503 // Begin calibration. This sets each limit to the worst
mjr 44:b5ac89b9cd5d 504 // case point - for example, we set the retracted position
mjr 44:b5ac89b9cd5d 505 // to all the way forward. Each actual reading that comes
mjr 44:b5ac89b9cd5d 506 // in is then checked against the current limit, and if it's
mjr 44:b5ac89b9cd5d 507 // outside of the limit, we reset the limit to the new reading.
mjr 44:b5ac89b9cd5d 508 void begin()
mjr 44:b5ac89b9cd5d 509 {
mjr 48:058ace2aed1d 510 min = 0; // we don't calibrate the maximum forward position, so keep this at zero
mjr 48:058ace2aed1d 511 zero = 0xffff; // set the zero position all the way back
mjr 48:058ace2aed1d 512 max = 0; // set the retracted position all the way forward
mjr 52:8298b2a73eb2 513 tRelease = 65; // revert to a default release time
mjr 35:e959ffba78fd 514 }
mjr 17:ab3cec0c8bf4 515
mjr 35:e959ffba78fd 516 } cal;
mjr 18:5e890ebd0023 517
mjr 35:e959ffba78fd 518 } plunger;
mjr 29:582472d0bc57 519
mjr 35:e959ffba78fd 520
mjr 35:e959ffba78fd 521 // --- TV ON SWITCH ---
mjr 35:e959ffba78fd 522 //
mjr 35:e959ffba78fd 523 // To use the TV ON switch feature, the special power sensing circuitry
mjr 35:e959ffba78fd 524 // implemented on the Expansion Board must be attached (or an equivalent
mjr 35:e959ffba78fd 525 // circuit, as described in the Build Guide). The circuitry lets us
mjr 35:e959ffba78fd 526 // detect power state changes on the secondary power supply.
mjr 35:e959ffba78fd 527 struct
mjr 35:e959ffba78fd 528 {
mjr 35:e959ffba78fd 529 // PSU2 power status sense (DigitalIn pin). This pin goes LOW when the
mjr 35:e959ffba78fd 530 // secondary power supply is turned off, and remains LOW until the LATCH
mjr 35:e959ffba78fd 531 // pin is raised high AND the secondary PSU is turned on. Once HIGH,
mjr 35:e959ffba78fd 532 // it remains HIGH as long as the secondary PSU is on.
mjr 35:e959ffba78fd 533 PinName statusPin;
mjr 35:e959ffba78fd 534
mjr 35:e959ffba78fd 535 // PSU2 power status latch (DigitalOut pin)
mjr 35:e959ffba78fd 536 PinName latchPin;
mjr 35:e959ffba78fd 537
mjr 35:e959ffba78fd 538 // TV ON relay pin (DigitalOut pin). This pin controls the TV switch
mjr 35:e959ffba78fd 539 // relay. Raising the pin HIGH turns the relay ON (energizes the coil).
mjr 35:e959ffba78fd 540 PinName relayPin;
mjr 35:e959ffba78fd 541
mjr 40:cc0d9814522b 542 // TV ON delay time, in 1/100 second units. This is the interval between
mjr 40:cc0d9814522b 543 // sensing that the secondary power supply has turned on and pulsing the
mjr 40:cc0d9814522b 544 // TV ON switch relay.
mjr 40:cc0d9814522b 545 int delayTime;
mjr 35:e959ffba78fd 546
mjr 35:e959ffba78fd 547 } TVON;
mjr 35:e959ffba78fd 548
mjr 29:582472d0bc57 549
mjr 35:e959ffba78fd 550 // --- TLC5940NT PWM Controller Chip Setup ---
mjr 35:e959ffba78fd 551 struct
mjr 35:e959ffba78fd 552 {
mjr 35:e959ffba78fd 553 // number of TLC5940NT chips connected in daisy chain
mjr 35:e959ffba78fd 554 int nchips;
mjr 35:e959ffba78fd 555
mjr 35:e959ffba78fd 556 // pin connections
mjr 35:e959ffba78fd 557 PinName sin; // Serial data - must connect to SPIO MOSI -> PTC6 or PTD2
mjr 35:e959ffba78fd 558 PinName sclk; // Serial clock - must connect to SPIO SCLK -> PTC5 or PTD1
mjr 35:e959ffba78fd 559 // (but don't use PTD1, since it's hard-wired to the on-board blue LED)
mjr 35:e959ffba78fd 560 PinName xlat; // XLAT (latch) signal - connect to any GPIO pin
mjr 35:e959ffba78fd 561 PinName blank; // BLANK signal - connect to any GPIO pin
mjr 35:e959ffba78fd 562 PinName gsclk; // Grayscale clock - must connect to a PWM-out capable pin
mjr 29:582472d0bc57 563
mjr 35:e959ffba78fd 564 } tlc5940;
mjr 35:e959ffba78fd 565
mjr 35:e959ffba78fd 566
mjr 35:e959ffba78fd 567 // --- 74HC595 Shift Register Setup ---
mjr 35:e959ffba78fd 568 struct
mjr 35:e959ffba78fd 569 {
mjr 35:e959ffba78fd 570 // number of 74HC595 chips attached in daisy chain
mjr 35:e959ffba78fd 571 int nchips;
mjr 35:e959ffba78fd 572
mjr 35:e959ffba78fd 573 // pin connections
mjr 35:e959ffba78fd 574 PinName sin; // Serial data - use any GPIO pin
mjr 35:e959ffba78fd 575 PinName sclk; // Serial clock - use any GPIO pin
mjr 35:e959ffba78fd 576 PinName latch; // Latch - use any GPIO pin
mjr 35:e959ffba78fd 577 PinName ena; // Enable signal - use any GPIO pin
mjr 35:e959ffba78fd 578
mjr 35:e959ffba78fd 579 } hc595;
mjr 34:6b981a2afab7 580
mjr 25:e22b88bd783a 581
mjr 35:e959ffba78fd 582 // --- Button Input Setup ---
mjr 40:cc0d9814522b 583 ButtonCfg button[MAX_BUTTONS] __attribute__((packed));
mjr 17:ab3cec0c8bf4 584
mjr 35:e959ffba78fd 585 // --- LedWiz Output Port Setup ---
mjr 38:091e511ce8a0 586 LedWizPortCfg outPort[MAX_OUT_PORTS] __attribute__((packed)); // LedWiz & extended output ports
mjr 38:091e511ce8a0 587 LedWizPortCfg specialPort[1]; // special ports (Night Mode indicator, etc)
mjr 48:058ace2aed1d 588
mjr 17:ab3cec0c8bf4 589 };
mjr 17:ab3cec0c8bf4 590
mjr 35:e959ffba78fd 591 #endif