work in progress

Dependencies:   FastAnalogIn FastIO USBDevice mbed FastPWM SimpleDMA

Fork of Pinscape_Controller by Mike R

Committer:
mjr
Date:
Sat Sep 26 02:15:59 2015 +0000
Revision:
34:cbff13b98441
Parent:
32:6e9902f06f48
Child:
35:d832bcab089e
Fix config.h for release version

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mjr 17:ab3cec0c8bf4 1 // Pinscape Controller Configuration
mjr 17:ab3cec0c8bf4 2 //
mjr 17:ab3cec0c8bf4 3 // To customize your private configuration, simply open this file in the
mjr 17:ab3cec0c8bf4 4 // mbed on-line IDE, make your changes, save the file, and click the Compile
mjr 17:ab3cec0c8bf4 5 // button at the top of the window. That will generate a customized .bin
mjr 17:ab3cec0c8bf4 6 // file that you can download onto your KL25Z board.
mjr 17:ab3cec0c8bf4 7
mjr 25:e22b88bd783a 8 #ifndef CONFIG_H
mjr 25:e22b88bd783a 9 #define CONFIG_H
mjr 17:ab3cec0c8bf4 10
mjr 17:ab3cec0c8bf4 11 // --------------------------------------------------------------------------
mjr 21:5048e16cc9ef 12 //
mjr 21:5048e16cc9ef 13 // Enable/disable joystick functions.
mjr 21:5048e16cc9ef 14 //
mjr 21:5048e16cc9ef 15 // This controls whether or not we send joystick reports to the PC with the
mjr 21:5048e16cc9ef 16 // plunger and accelerometer readings. By default, this is enabled. If
mjr 21:5048e16cc9ef 17 // you want to use two or more physical KL25Z Pinscape controllers in your
mjr 21:5048e16cc9ef 18 // system (e.g., if you want to increase the number of output ports
mjr 21:5048e16cc9ef 19 // available by using two or more KL25Z's), you should disable the joystick
mjr 21:5048e16cc9ef 20 // features on the second (and third+) controller. It's not useful to have
mjr 21:5048e16cc9ef 21 // more than one board reporting the accelerometer readings to the host -
mjr 21:5048e16cc9ef 22 // doing so will just add USB overhead. This setting lets you turn off the
mjr 21:5048e16cc9ef 23 // reports for the secondary controllers, turning the secondary boards into
mjr 21:5048e16cc9ef 24 // output-only devices.
mjr 21:5048e16cc9ef 25 //
mjr 21:5048e16cc9ef 26 // Note that you can't use button inputs on a controller that has the
mjr 21:5048e16cc9ef 27 // joystick features disabled, because the buttons are handled via the
mjr 21:5048e16cc9ef 28 // joystick reports. Wire all of your buttons to the primary KL25Z that
mjr 21:5048e16cc9ef 29 // has the joystick features enabled.
mjr 21:5048e16cc9ef 30 //
mjr 21:5048e16cc9ef 31 // To disable the joystick features, just comment out the next line (add
mjr 21:5048e16cc9ef 32 // two slashes at the beginning of the line).
mjr 21:5048e16cc9ef 33 //
mjr 21:5048e16cc9ef 34 #define ENABLE_JOYSTICK
mjr 21:5048e16cc9ef 35
mjr 21:5048e16cc9ef 36
mjr 25:e22b88bd783a 37 // Accelerometer orientation. The accelerometer feature lets Visual Pinball
mjr 25:e22b88bd783a 38 // (and other pinball software) sense nudges to the cabinet, and simulate
mjr 25:e22b88bd783a 39 // the effect on the ball's trajectory during play. We report the direction
mjr 25:e22b88bd783a 40 // of the accelerometer readings as well as the strength, so it's important
mjr 25:e22b88bd783a 41 // for VP and the KL25Z to agree on the physical orientation of the
mjr 25:e22b88bd783a 42 // accelerometer relative to the cabinet. The accelerometer on the KL25Z
mjr 25:e22b88bd783a 43 // is always mounted the same way on the board, but we still have to know
mjr 25:e22b88bd783a 44 // which way you mount the board in your cabinet. We assume as default
mjr 25:e22b88bd783a 45 // orientation where the KL25Z is mounted flat on the bottom of your
mjr 25:e22b88bd783a 46 // cabinet with the USB ports pointing forward, toward the coin door. If
mjr 25:e22b88bd783a 47 // it's more convenient for you to mount the board in a different direction,
mjr 25:e22b88bd783a 48 // you simply need to select the matching direction here. Comment out the
mjr 25:e22b88bd783a 49 // ORIENTATION_PORTS_AT_FRONT line and un-comment the line that matches
mjr 25:e22b88bd783a 50 // your board's orientation.
mjr 25:e22b88bd783a 51
mjr 25:e22b88bd783a 52 #define ORIENTATION_PORTS_AT_FRONT // USB ports pointing toward front of cabinet
mjr 25:e22b88bd783a 53 // #define ORIENTATION_PORTS_AT_LEFT // USB ports pointing toward left side of cab
mjr 25:e22b88bd783a 54 // #define ORIENTATION_PORTS_AT_RIGHT // USB ports pointing toward right side of cab
mjr 25:e22b88bd783a 55 // #define ORIENTATION_PORTS_AT_REAR // USB ports pointing toward back of cabinet
mjr 25:e22b88bd783a 56
mjr 25:e22b88bd783a 57
mjr 21:5048e16cc9ef 58 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 59 //
mjr 17:ab3cec0c8bf4 60 // LedWiz default unit number.
mjr 17:ab3cec0c8bf4 61 //
mjr 21:5048e16cc9ef 62 // Each LedWiz device has a unit number, from 1 to 16. This lets you install
mjr 17:ab3cec0c8bf4 63 // more than one LedWiz in your system: as long as each one has a different
mjr 17:ab3cec0c8bf4 64 // unit number, the software on the PC can tell them apart and route commands
mjr 17:ab3cec0c8bf4 65 // to the right device.
mjr 17:ab3cec0c8bf4 66 //
mjr 21:5048e16cc9ef 67 // A *real* LedWiz has its unit number set at the factory; they set it to
mjr 21:5048e16cc9ef 68 // unit 1 unless you specifically request a different number when you place
mjr 21:5048e16cc9ef 69 // your order.
mjr 21:5048e16cc9ef 70 //
mjr 21:5048e16cc9ef 71 // For our *emulated* LedWiz, we default to unit #8. However, if we're set
mjr 21:5048e16cc9ef 72 // up as a secondary Pinscape controller with the joystick functions turned
mjr 21:5048e16cc9ef 73 // off, we'll use unit #9 instead.
mjr 17:ab3cec0c8bf4 74 //
mjr 21:5048e16cc9ef 75 // The reason we start at unit #8 is that we want to avoid conflicting with
mjr 21:5048e16cc9ef 76 // any real LedWiz devices you have in your system. If you have a real
mjr 31:582472d0bc57 77 // LedWiz, it's probably unit #1, since that's the default factory setting
mjr 31:582472d0bc57 78 // that they'll give you if you didn't specifically ask for something else
mjr 31:582472d0bc57 79 // when you ordered it. If you have two real LedWiz's, they're probably
mjr 31:582472d0bc57 80 // units #1 and #2. If you have three... well, I don't think anyone
mjr 31:582472d0bc57 81 // actually has three, but if you did it would probably be unit #3. And so
mjr 31:582472d0bc57 82 // on. That's why we start at #8: it seems really unlikely that anyone
mjr 31:582472d0bc57 83 // with a pin cab has a real LedWiz unit #8. On the off chance that you
mjr 31:582472d0bc57 84 // do, simply change the setting here to a different unit number that's not
mjr 31:582472d0bc57 85 // already used in your system.
mjr 17:ab3cec0c8bf4 86 //
mjr 21:5048e16cc9ef 87 // Note 1: the unit number here is the *user visible* unit number that
mjr 21:5048e16cc9ef 88 // you use on the PC side. It's the number you specify in your DOF
mjr 21:5048e16cc9ef 89 // configuration and so forth. Internally, the USB reports subtract
mjr 21:5048e16cc9ef 90 // one from this number - e.g., nominal unit #1 shows up as 0 in the USB
mjr 21:5048e16cc9ef 91 // reports. If you're trying to puzzle out why all of the USB reports
mjr 21:5048e16cc9ef 92 // are all off by one from the unit number you select here, that's why.
mjr 17:ab3cec0c8bf4 93 //
mjr 17:ab3cec0c8bf4 94 // Note 2: the DOF Configtool (google it) knows about the Pinscape
mjr 31:582472d0bc57 95 // controller. There it's referred to as simply "KL25Z" rather than
mjr 31:582472d0bc57 96 // Pinscape Controller, but that's what they're talking about. The DOF
mjr 31:582472d0bc57 97 // tool knows that it uses #8 as its default unit number, so it names the
mjr 31:582472d0bc57 98 // .ini file for this controller xxx8.ini. If you change the unit number
mjr 31:582472d0bc57 99 // here, remember to rename the DOF-generated .ini file to match, by
mjr 31:582472d0bc57 100 // changing the "8" at the end of the filename to the new number you set
mjr 31:582472d0bc57 101 // here.
mjr 21:5048e16cc9ef 102 const uint8_t DEFAULT_LEDWIZ_UNIT_NUMBER =
mjr 21:5048e16cc9ef 103 #ifdef ENABLE_JOYSTICK
mjr 32:6e9902f06f48 104 0x08; // joystick enabled - assume we're the primary KL25Z, so use unit #8
mjr 21:5048e16cc9ef 105 #else
mjr 21:5048e16cc9ef 106 0x09; // joystick disabled - assume we're a secondary, output-only KL25Z, so use #9
mjr 21:5048e16cc9ef 107 #endif
mjr 17:ab3cec0c8bf4 108
mjr 17:ab3cec0c8bf4 109 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 110 //
mjr 17:ab3cec0c8bf4 111 // Plunger CCD sensor.
mjr 17:ab3cec0c8bf4 112 //
mjr 17:ab3cec0c8bf4 113 // If you're NOT using the CCD sensor, comment out the next line (by adding
mjr 17:ab3cec0c8bf4 114 // two slashes at the start of the line).
mjr 17:ab3cec0c8bf4 115
mjr 24:e902bc7cdc1e 116 #define ENABLE_CCD_SENSOR
mjr 17:ab3cec0c8bf4 117
mjr 25:e22b88bd783a 118 // Physical pixel count for your sensor. This software has been tested with
mjr 25:e22b88bd783a 119 // TAOS TSL1410R (1280 pixels) and TSL1412R (1536 pixels) sensors. It might
mjr 25:e22b88bd783a 120 // work with other similar sensors as well, but you'll probably have to make
mjr 25:e22b88bd783a 121 // some changes to the software interface to the sensor if you're using any
mjr 25:e22b88bd783a 122 // sensor outside of the TAOS TSL14xxR series.
mjr 25:e22b88bd783a 123 //
mjr 25:e22b88bd783a 124 // If you're not using a CCD sensor, you can ignore this.
mjr 25:e22b88bd783a 125 const int CCD_NPIXELS = 1280;
mjr 25:e22b88bd783a 126
mjr 25:e22b88bd783a 127 // Number of pixels from the CCD to sample on each high-res scan. We don't
mjr 25:e22b88bd783a 128 // sample every pixel from the sensor on each scan, because (a) we don't
mjr 25:e22b88bd783a 129 // have to, and (b) we don't want to. We don't have to sample all of the
mjr 25:e22b88bd783a 130 // pixels because these sensors have much finer resolution than we need to
mjr 25:e22b88bd783a 131 // get good results. On a typical pinball cabinet setup with a 1920x1080
mjr 25:e22b88bd783a 132 // HD TV display, the on-screen plunger travel distance is about 165 pixels,
mjr 25:e22b88bd783a 133 // so that's all the pixels we need to sample for pixel-accurate animation.
mjr 25:e22b88bd783a 134 // Even so, we still *could* sample at higher resolution, but we don't *want*
mjr 25:e22b88bd783a 135 // to sample more pixels than we have to, because reading each pixel takes
mjr 25:e22b88bd783a 136 // time. The limiting factor for read speed is the sampling time for the ADC
mjr 25:e22b88bd783a 137 // (analog to digital converter); it needs about 20us per sample to get an
mjr 25:e22b88bd783a 138 // accurate voltage reading. We want to animate the on-screen plunger in
mjr 25:e22b88bd783a 139 // real time, with minimal lag, so it's important that we complete each scan
mjr 25:e22b88bd783a 140 // as quickly as possible. The fewer pixels we sample, the faster we
mjr 25:e22b88bd783a 141 // complete each scan.
mjr 25:e22b88bd783a 142 //
mjr 25:e22b88bd783a 143 // Happily, the time needed to read the approximately 165 pixels required
mjr 25:e22b88bd783a 144 // for pixel-accurate positioning on the display is short enough that we can
mjr 25:e22b88bd783a 145 // complete a scan within the cycle time for USB reports. USB gives us a
mjr 25:e22b88bd783a 146 // whole separate timing factor; we can't go much *faster* with USB than
mjr 25:e22b88bd783a 147 // sending a new report about every 10ms. The sensor timing is such that
mjr 25:e22b88bd783a 148 // we can read about 165 pixels in well under 10ms. So that's really the
mjr 25:e22b88bd783a 149 // sweet spot for our scans.
mjr 25:e22b88bd783a 150 //
mjr 25:e22b88bd783a 151 // Note that we distribute the sampled pixels evenly across the full range
mjr 25:e22b88bd783a 152 // of the sensor's pixels. That is, we read every nth pixel, and skip the
mjr 25:e22b88bd783a 153 // ones in between. That means that the sample count here has to be an even
mjr 25:e22b88bd783a 154 // divisor of the physical pixel count. Empirically, reading every 8th
mjr 25:e22b88bd783a 155 // pixel gives us good results on both the TSL1410R and TSL1412R, so you
mjr 25:e22b88bd783a 156 // shouldn't need to change this if you're using one of those sensors. If
mjr 25:e22b88bd783a 157 // you're using a different sensor, you should be sure to adjust this so that
mjr 25:e22b88bd783a 158 // it works out to an integer result with no remainder.
mjr 25:e22b88bd783a 159 //
mjr 25:e22b88bd783a 160 const int CCD_NPIXELS_SAMPLED = CCD_NPIXELS / 8;
mjr 25:e22b88bd783a 161
mjr 17:ab3cec0c8bf4 162 // The KL25Z pins that the CCD sensor is physically attached to:
mjr 17:ab3cec0c8bf4 163 //
mjr 17:ab3cec0c8bf4 164 // CCD_SI_PIN = the SI (sensor data input) pin
mjr 17:ab3cec0c8bf4 165 // CCD_CLOCK_PIN = the sensor clock pin
mjr 17:ab3cec0c8bf4 166 // CCD_SO_PIN = the SO (sensor data output) pin
mjr 17:ab3cec0c8bf4 167 //
mjr 17:ab3cec0c8bf4 168 // The SI an Clock pins are DigitalOut pins, so these can be set to just
mjr 17:ab3cec0c8bf4 169 // about any gpio pins that aren't used for something else. The SO pin must
mjr 17:ab3cec0c8bf4 170 // be an AnalogIn capable pin - only a few of the KL25Z gpio pins qualify,
mjr 17:ab3cec0c8bf4 171 // so check the pinout diagram to find suitable candidates if you need to
mjr 17:ab3cec0c8bf4 172 // change this. Note that some of the gpio pins shown in the mbed pinout
mjr 17:ab3cec0c8bf4 173 // diagrams are committed to other uses by the mbed software or by the KL25Z
mjr 17:ab3cec0c8bf4 174 // wiring itself, so if you do change these, be sure that the new pins you
mjr 17:ab3cec0c8bf4 175 // select are really available.
mjr 17:ab3cec0c8bf4 176
mjr 17:ab3cec0c8bf4 177 const PinName CCD_SI_PIN = PTE20;
mjr 17:ab3cec0c8bf4 178 const PinName CCD_CLOCK_PIN = PTE21;
mjr 17:ab3cec0c8bf4 179 const PinName CCD_SO_PIN = PTB0;
mjr 17:ab3cec0c8bf4 180
mjr 17:ab3cec0c8bf4 181 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 182 //
mjr 17:ab3cec0c8bf4 183 // Plunger potentiometer sensor.
mjr 17:ab3cec0c8bf4 184 //
mjr 23:14f8c5004cd0 185 // If you're using a potentiometer as the plunger sensor, un-comment the
mjr 23:14f8c5004cd0 186 // next line (by removing the two slashes at the start of the line), and
mjr 23:14f8c5004cd0 187 // also comment out the ENABLE_CCD_SENSOR line above.
mjr 17:ab3cec0c8bf4 188
mjr 24:e902bc7cdc1e 189 //#define ENABLE_POT_SENSOR
mjr 17:ab3cec0c8bf4 190
mjr 23:14f8c5004cd0 191 // The KL25Z pin that your potentiometer is attached to. The potentiometer
mjr 23:14f8c5004cd0 192 // requires wiring three connectins:
mjr 23:14f8c5004cd0 193 //
mjr 23:14f8c5004cd0 194 // - Wire the fixed resistance end of the potentiometer nearest the KNOB
mjr 23:14f8c5004cd0 195 // end of the plunger to the 3.3V output from the KL25Z
mjr 23:14f8c5004cd0 196 //
mjr 23:14f8c5004cd0 197 // - Wire the other fixed resistance end to KL25Z Ground
mjr 23:14f8c5004cd0 198 //
mjr 23:14f8c5004cd0 199 // - Wire the potentiometer wiper (the variable output terminal) to the
mjr 23:14f8c5004cd0 200 // KL25Z pin identified below.
mjr 23:14f8c5004cd0 201 //
mjr 23:14f8c5004cd0 202 // Note that you can change the pin selection below, but if you do, the new
mjr 23:14f8c5004cd0 203 // pin must be AnalogIn capable. Only a few of the KL25Z pins qualify. Refer
mjr 23:14f8c5004cd0 204 // to the KL25Z pinout diagram to find another AnalogIn pin if you need to
mjr 23:14f8c5004cd0 205 // change this for any reason. Note that the default is to use the same analog
mjr 23:14f8c5004cd0 206 // input that the CCD sensor would use if it were enabled, which is why you
mjr 23:14f8c5004cd0 207 // have to be sure to disable the CCD support in the software if you're using
mjr 23:14f8c5004cd0 208 // a potentiometer as the sensor.
mjr 17:ab3cec0c8bf4 209
mjr 17:ab3cec0c8bf4 210 const PinName POT_PIN = PTB0;
mjr 17:ab3cec0c8bf4 211
mjr 17:ab3cec0c8bf4 212 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 213 //
mjr 17:ab3cec0c8bf4 214 // Plunger calibration button and indicator light.
mjr 17:ab3cec0c8bf4 215 //
mjr 17:ab3cec0c8bf4 216 // These specify the pin names of the plunger calibration button connections.
mjr 17:ab3cec0c8bf4 217 // If you're not using these, you can set these to NC. (You can even use the
mjr 17:ab3cec0c8bf4 218 // button but not the LED; set the LED to NC if you're only using the button.)
mjr 17:ab3cec0c8bf4 219 //
mjr 17:ab3cec0c8bf4 220 // If you're using the button, wire one terminal of a momentary switch or
mjr 17:ab3cec0c8bf4 221 // pushbutton to the input pin you select, and wire the other terminal to the
mjr 17:ab3cec0c8bf4 222 // KL25Z ground. Push and hold the button for a few seconds to enter plunger
mjr 17:ab3cec0c8bf4 223 // calibration mode.
mjr 17:ab3cec0c8bf4 224 //
mjr 17:ab3cec0c8bf4 225 // If you're using the LED, you'll need to build a little transistor power
mjr 17:ab3cec0c8bf4 226 // booster circuit to power the LED, as described in the build guide. The
mjr 17:ab3cec0c8bf4 227 // LED gives you visual confirmation that the you've triggered calibration
mjr 17:ab3cec0c8bf4 228 // mode and lets you know when the mode times out. Note that the LED on
mjr 17:ab3cec0c8bf4 229 // board the KL25Z also changes color to indicate the same information, so
mjr 17:ab3cec0c8bf4 230 // if the KL25Z is positioned so that you can see it while you're doing the
mjr 17:ab3cec0c8bf4 231 // calibration, you don't really need a separate button LED. But the
mjr 17:ab3cec0c8bf4 232 // separate LED is spiffy, especially if it's embedded in the pushbutton.
mjr 17:ab3cec0c8bf4 233 //
mjr 17:ab3cec0c8bf4 234 // Note that you can skip the pushbutton altogether and trigger calibration
mjr 17:ab3cec0c8bf4 235 // from the Windows control software. But again, the button is spiffier.
mjr 17:ab3cec0c8bf4 236
mjr 17:ab3cec0c8bf4 237 // calibration button input
mjr 17:ab3cec0c8bf4 238 const PinName CAL_BUTTON_PIN = PTE29;
mjr 17:ab3cec0c8bf4 239
mjr 17:ab3cec0c8bf4 240 // calibration button indicator LED
mjr 17:ab3cec0c8bf4 241 const PinName CAL_BUTTON_LED = PTE23;
mjr 17:ab3cec0c8bf4 242
mjr 17:ab3cec0c8bf4 243
mjr 17:ab3cec0c8bf4 244 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 245 //
mjr 17:ab3cec0c8bf4 246 // Pseudo "Launch Ball" button.
mjr 17:ab3cec0c8bf4 247 //
mjr 17:ab3cec0c8bf4 248 // Zeb of zebsboards.com came up with a clever scheme for his plunger kit
mjr 17:ab3cec0c8bf4 249 // that lets the plunger simulate a Launch Ball button for tables where
mjr 17:ab3cec0c8bf4 250 // the original used a Launch button instead of a plunger (e.g., Medieval
mjr 17:ab3cec0c8bf4 251 // Madness, T2, or Star Trek: The Next Generation). The scheme uses an
mjr 17:ab3cec0c8bf4 252 // LedWiz output to tell us when such a table is loaded. On the DOF
mjr 17:ab3cec0c8bf4 253 // Configtool site, this is called "ZB Launch Ball". When this LedWiz
mjr 17:ab3cec0c8bf4 254 // output is ON, it tells us that the table will ignore the analog plunger
mjr 17:ab3cec0c8bf4 255 // because it doesn't have a plunger object, so the analog plunger should
mjr 17:ab3cec0c8bf4 256 // send a Launch Ball button press signal when the user releases the plunger.
mjr 17:ab3cec0c8bf4 257 //
mjr 17:ab3cec0c8bf4 258 // If you wish to use this feature, you need to do two things:
mjr 17:ab3cec0c8bf4 259 //
mjr 17:ab3cec0c8bf4 260 // First, adjust the two lines below to set the LedWiz output and joystick
mjr 17:ab3cec0c8bf4 261 // button you wish to use for this feature. The defaults below should be
mjr 17:ab3cec0c8bf4 262 // fine for most people, but if you're using the Pinscape controller for
mjr 17:ab3cec0c8bf4 263 // your physical button wiring, you should set the launch button to match
mjr 17:ab3cec0c8bf4 264 // where you physically wired your actual Launch Ball button. Likewise,
mjr 17:ab3cec0c8bf4 265 // change the LedWiz port if you're using the one below for some actual
mjr 17:ab3cec0c8bf4 266 // hardware output. This is a virtual port that won't control any hardware;
mjr 17:ab3cec0c8bf4 267 // it's just for signaling the plunger that we're in "button mode". Note
mjr 17:ab3cec0c8bf4 268 // that the numbering for the both the LedWiz port and joystick button
mjr 17:ab3cec0c8bf4 269 // start at 1 to match the DOF Configtool and VP dialog numbering.
mjr 17:ab3cec0c8bf4 270 //
mjr 17:ab3cec0c8bf4 271 // Second, in the DOF Configtool, make sure you have a Pinscape controller
mjr 17:ab3cec0c8bf4 272 // in your cabinet configuration, then go to your Port Assignments and set
mjr 17:ab3cec0c8bf4 273 // the port defined below to "ZB Launch Ball".
mjr 17:ab3cec0c8bf4 274 //
mjr 17:ab3cec0c8bf4 275 // Third, open the Visual Pinball editor, open the Preferences | Keys
mjr 17:ab3cec0c8bf4 276 // dialog, and find the Plunger item. Open the drop-down list under that
mjr 17:ab3cec0c8bf4 277 // item and select the button number defined below.
mjr 17:ab3cec0c8bf4 278 //
mjr 21:5048e16cc9ef 279 // To disable this feature, just set ZBLaunchBallPort to 0 here.
mjr 17:ab3cec0c8bf4 280
mjr 17:ab3cec0c8bf4 281 const int ZBLaunchBallPort = 32;
mjr 17:ab3cec0c8bf4 282 const int LaunchBallButton = 24;
mjr 17:ab3cec0c8bf4 283
mjr 18:5e890ebd0023 284 // Distance necessary to push the plunger to activate the simulated
mjr 18:5e890ebd0023 285 // launch ball button, in inches. A standard pinball plunger can be
mjr 18:5e890ebd0023 286 // pushed forward about 1/2". However, the barrel spring is very
mjr 18:5e890ebd0023 287 // stiff, and anything more than about 1/8" requires quite a bit
mjr 18:5e890ebd0023 288 // of force. Ideally the force required should be about the same as
mjr 18:5e890ebd0023 289 // for any ordinary pushbutton.
mjr 18:5e890ebd0023 290 //
mjr 18:5e890ebd0023 291 // On my cabinet, empirically, a distance around 2mm (.08") seems
mjr 18:5e890ebd0023 292 // to work pretty well. It's far enough that it doesn't trigger
mjr 18:5e890ebd0023 293 // spuriously, but short enough that it responds to a reasonably
mjr 18:5e890ebd0023 294 // light push.
mjr 18:5e890ebd0023 295 //
mjr 18:5e890ebd0023 296 // You might need to adjust this up or down to get the right feel.
mjr 18:5e890ebd0023 297 // Alternatively, if you don't like the "push" gesture at all and
mjr 18:5e890ebd0023 298 // would prefer to only make the plunger respond to a pull-and-release
mjr 18:5e890ebd0023 299 // motion, simply set this to, say, 2.0 - it's impossible to push a
mjr 18:5e890ebd0023 300 // plunger forward that far, so that will effectively turn off the
mjr 18:5e890ebd0023 301 // push mode.
mjr 18:5e890ebd0023 302 const float LaunchBallPushDistance = .08;
mjr 18:5e890ebd0023 303
mjr 31:582472d0bc57 304
mjr 31:582472d0bc57 305 // --------------------------------------------------------------------------
mjr 31:582472d0bc57 306 //
mjr 31:582472d0bc57 307 // TLC5940 PWM controller chip setup - Enhanced LedWiz emulation
mjr 31:582472d0bc57 308 //
mjr 31:582472d0bc57 309 // By default, the Pinscape Controller software can provide limited LedWiz
mjr 31:582472d0bc57 310 // emulation through the KL25Z's on-board GPIO ports. This lets you hook
mjr 31:582472d0bc57 311 // up external devices, such as LED flashers or solenoids, to the KL25Z
mjr 31:582472d0bc57 312 // outputs (using external circuitry to boost power - KL25Z GPIO ports
mjr 31:582472d0bc57 313 // are limited to a meager 4mA per port). This capability is limited by
mjr 31:582472d0bc57 314 // the number of available GPIO ports on the KL25Z, and even smaller limit
mjr 31:582472d0bc57 315 // of 10 PWM-capable GPIO ports.
mjr 31:582472d0bc57 316 //
mjr 31:582472d0bc57 317 // As an alternative, the controller software lets you use external PWM
mjr 31:582472d0bc57 318 // controller chips to control essentially unlimited channels with full
mjr 31:582472d0bc57 319 // PWM control on all channels. This requires building external circuitry
mjr 31:582472d0bc57 320 // using TLC5940 chips. Each TLC5940 chip provides 16 full PWM channels,
mjr 31:582472d0bc57 321 // and you can daisy-chain multiple TLC5940 chips together to set up 32,
mjr 31:582472d0bc57 322 // 48, 64, or more channels.
mjr 31:582472d0bc57 323 //
mjr 31:582472d0bc57 324 // If you do add TLC5940 circuits to your controller hardware, use this
mjr 31:582472d0bc57 325 // section to configure the connection to the KL25Z.
mjr 31:582472d0bc57 326 //
mjr 31:582472d0bc57 327 // Note that if you're using TLC5940 outputs, ALL of the outputs must go
mjr 31:582472d0bc57 328 // through the TLC5940s - you can't mix TLC5940s and the default GPIO
mjr 31:582472d0bc57 329 // device outputs. This lets us take GPIO ports that we'd normally use
mjr 31:582472d0bc57 330 // for device outputs and reassign them to control the TLC5940 hardware.
mjr 31:582472d0bc57 331
mjr 31:582472d0bc57 332 // Uncomment this line if using TLC5940 chips
mjr 34:cbff13b98441 333 //#define ENABLE_TLC5940
mjr 31:582472d0bc57 334
mjr 31:582472d0bc57 335 // Number of TLC5940 chips you're using. For a full LedWiz-compatible
mjr 31:582472d0bc57 336 // setup, you need two of these chips, for 32 outputs.
mjr 31:582472d0bc57 337 #define TLC5940_NCHIPS 4
mjr 31:582472d0bc57 338
mjr 31:582472d0bc57 339 // If you're using TLC5940s, change any of these as needed to match the
mjr 31:582472d0bc57 340 // GPIO pins that you connected to the TLC5940 control pins. Note that
mjr 31:582472d0bc57 341 // SIN and SCLK *must* be connected to the KL25Z SPI0 MOSI and SCLK
mjr 31:582472d0bc57 342 // outputs, respectively, which effectively limits them to the default
mjr 31:582472d0bc57 343 // selections, and that the GSCLK pin must be PWM-capable.
mjr 31:582472d0bc57 344 #define TLC5940_SIN PTC6 // Must connect to SPI0 MOSI -> PTC6 or PTD2
mjr 31:582472d0bc57 345 #define TLC5940_SCLK PTC5 // Must connect to SPI0 SCLK -> PTC5 or PTD1; however, PTD1 isn't
mjr 31:582472d0bc57 346 // recommended because it's hard-wired to the on-board blue LED
mjr 31:582472d0bc57 347 #define TLC5940_XLAT PTC10 // Any GPIO pin can be used
mjr 31:582472d0bc57 348 #define TLC5940_BLANK PTC0 // Any GPIO pin can be used
mjr 31:582472d0bc57 349 #define TLC5940_GSCLK PTD4 // Must be a PWM-capable pin
mjr 25:e22b88bd783a 350
mjr 17:ab3cec0c8bf4 351
mjr 31:582472d0bc57 352 #endif // CONFIG_H - end of include-once section (code below this point can be multiply included)
mjr 31:582472d0bc57 353
mjr 31:582472d0bc57 354
mjr 31:582472d0bc57 355 #ifdef DECL_EXTERNS // this section defines global variables, only if this macro is set
mjr 31:582472d0bc57 356
mjr 17:ab3cec0c8bf4 357 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 358 //
mjr 17:ab3cec0c8bf4 359
mjr 17:ab3cec0c8bf4 360 // Joystick button input pin assignments.
mjr 17:ab3cec0c8bf4 361 //
mjr 17:ab3cec0c8bf4 362 // You can wire up to 32 GPIO ports to buttons (equipped with
mjr 17:ab3cec0c8bf4 363 // momentary switches). Connect each switch between the desired
mjr 17:ab3cec0c8bf4 364 // GPIO port and ground (J9 pin 12 or 14). When the button is pressed,
mjr 17:ab3cec0c8bf4 365 // we'll tell the host PC that the corresponding joystick button is
mjr 17:ab3cec0c8bf4 366 // pressed. We debounce the keystrokes in software, so you can simply
mjr 17:ab3cec0c8bf4 367 // wire directly to pushbuttons with no additional external hardware.
mjr 17:ab3cec0c8bf4 368 //
mjr 17:ab3cec0c8bf4 369 // Note that we assign 24 buttons by default, even though the USB
mjr 17:ab3cec0c8bf4 370 // joystick interface can handle up to 32 buttons. VP itself only
mjr 17:ab3cec0c8bf4 371 // allows mapping of up to 24 buttons in the preferences dialog
mjr 17:ab3cec0c8bf4 372 // (although it can recognize 32 buttons internally). If you want
mjr 17:ab3cec0c8bf4 373 // more buttons, you can reassign pins that are assigned by default
mjr 17:ab3cec0c8bf4 374 // as LedWiz outputs. To reassign a pin, find the pin you wish to
mjr 17:ab3cec0c8bf4 375 // reassign in the LedWizPortMap array below, and change the pin name
mjr 17:ab3cec0c8bf4 376 // there to NC (for Not Connected). You can then change one of the
mjr 17:ab3cec0c8bf4 377 // "NC" entries below to the reallocated pin name. The limit is 32
mjr 17:ab3cec0c8bf4 378 // buttons total.
mjr 17:ab3cec0c8bf4 379 //
mjr 28:cb71c4af2912 380 // (If you're using TLC5940 chips to control outputs, ALL of the
mjr 28:cb71c4af2912 381 // LedWiz mapped ports can be reassigned as keys, except, of course,
mjr 28:cb71c4af2912 382 // those taken over for the 5940 interface.)
mjr 28:cb71c4af2912 383 //
mjr 17:ab3cec0c8bf4 384 // Note: PTD1 (pin J2-12) should NOT be assigned as a button input,
mjr 17:ab3cec0c8bf4 385 // as this pin is physically connected on the KL25Z to the on-board
mjr 17:ab3cec0c8bf4 386 // indicator LED's blue segment. This precludes any other use of
mjr 17:ab3cec0c8bf4 387 // the pin.
mjr 17:ab3cec0c8bf4 388 PinName buttonMap[] = {
mjr 17:ab3cec0c8bf4 389 PTC2, // J10 pin 10, joystick button 1
mjr 17:ab3cec0c8bf4 390 PTB3, // J10 pin 8, joystick button 2
mjr 17:ab3cec0c8bf4 391 PTB2, // J10 pin 6, joystick button 3
mjr 17:ab3cec0c8bf4 392 PTB1, // J10 pin 4, joystick button 4
mjr 17:ab3cec0c8bf4 393
mjr 17:ab3cec0c8bf4 394 PTE30, // J10 pin 11, joystick button 5
mjr 17:ab3cec0c8bf4 395 PTE22, // J10 pin 5, joystick button 6
mjr 17:ab3cec0c8bf4 396
mjr 17:ab3cec0c8bf4 397 PTE5, // J9 pin 15, joystick button 7
mjr 17:ab3cec0c8bf4 398 PTE4, // J9 pin 13, joystick button 8
mjr 17:ab3cec0c8bf4 399 PTE3, // J9 pin 11, joystick button 9
mjr 17:ab3cec0c8bf4 400 PTE2, // J9 pin 9, joystick button 10
mjr 17:ab3cec0c8bf4 401 PTB11, // J9 pin 7, joystick button 11
mjr 17:ab3cec0c8bf4 402 PTB10, // J9 pin 5, joystick button 12
mjr 17:ab3cec0c8bf4 403 PTB9, // J9 pin 3, joystick button 13
mjr 17:ab3cec0c8bf4 404 PTB8, // J9 pin 1, joystick button 14
mjr 17:ab3cec0c8bf4 405
mjr 17:ab3cec0c8bf4 406 PTC12, // J2 pin 1, joystick button 15
mjr 17:ab3cec0c8bf4 407 PTC13, // J2 pin 3, joystick button 16
mjr 17:ab3cec0c8bf4 408 PTC16, // J2 pin 5, joystick button 17
mjr 17:ab3cec0c8bf4 409 PTC17, // J2 pin 7, joystick button 18
mjr 17:ab3cec0c8bf4 410 PTA16, // J2 pin 9, joystick button 19
mjr 17:ab3cec0c8bf4 411 PTA17, // J2 pin 11, joystick button 20
mjr 17:ab3cec0c8bf4 412 PTE31, // J2 pin 13, joystick button 21
mjr 17:ab3cec0c8bf4 413 PTD6, // J2 pin 17, joystick button 22
mjr 17:ab3cec0c8bf4 414 PTD7, // J2 pin 19, joystick button 23
mjr 17:ab3cec0c8bf4 415
mjr 17:ab3cec0c8bf4 416 PTE1, // J2 pin 20, joystick button 24
mjr 17:ab3cec0c8bf4 417
mjr 17:ab3cec0c8bf4 418 NC, // not used, joystick button 25
mjr 17:ab3cec0c8bf4 419 NC, // not used, joystick button 26
mjr 17:ab3cec0c8bf4 420 NC, // not used, joystick button 27
mjr 17:ab3cec0c8bf4 421 NC, // not used, joystick button 28
mjr 17:ab3cec0c8bf4 422 NC, // not used, joystick button 29
mjr 17:ab3cec0c8bf4 423 NC, // not used, joystick button 30
mjr 17:ab3cec0c8bf4 424 NC, // not used, joystick button 31
mjr 17:ab3cec0c8bf4 425 NC // not used, joystick button 32
mjr 17:ab3cec0c8bf4 426 };
mjr 17:ab3cec0c8bf4 427
mjr 17:ab3cec0c8bf4 428 // --------------------------------------------------------------------------
mjr 17:ab3cec0c8bf4 429 //
mjr 31:582472d0bc57 430 // LED-Wiz emulation output pin assignments - GPIO mode
mjr 17:ab3cec0c8bf4 431 //
mjr 28:cb71c4af2912 432 // NOTE! This section isn't used if you have TLC5940 outputs - ALL
mjr 28:cb71c4af2912 433 // device outputs will be through the 5940s if you're using them.
mjr 28:cb71c4af2912 434 // See the TLC5940 setup section above to configure your interface
mjr 28:cb71c4af2912 435 // pins if you're using those chips.
mjr 28:cb71c4af2912 436 //
mjr 17:ab3cec0c8bf4 437 // The LED-Wiz protocol allows setting individual intensity levels
mjr 17:ab3cec0c8bf4 438 // on all outputs, with 48 levels of intensity. This can be used
mjr 17:ab3cec0c8bf4 439 // to control lamp brightness and motor speeds, among other things.
mjr 17:ab3cec0c8bf4 440 // Unfortunately, the KL25Z only has 10 PWM channels, so while we
mjr 17:ab3cec0c8bf4 441 // can support the full complement of 32 outputs, we can only provide
mjr 17:ab3cec0c8bf4 442 // PWM dimming/speed control on 10 of them. The remaining outputs
mjr 17:ab3cec0c8bf4 443 // can only be switched fully on and fully off - we can't support
mjr 17:ab3cec0c8bf4 444 // dimming on these, so they'll ignore any intensity level setting
mjr 17:ab3cec0c8bf4 445 // requested by the host. Use these for devices that don't have any
mjr 17:ab3cec0c8bf4 446 // use for intensity settings anyway, such as contactors and knockers.
mjr 17:ab3cec0c8bf4 447 //
mjr 17:ab3cec0c8bf4 448 // Ports with pins assigned as "NC" are not connected. That is,
mjr 17:ab3cec0c8bf4 449 // there's no physical pin for that LedWiz port number. You can
mjr 17:ab3cec0c8bf4 450 // send LedWiz commands to turn NC ports on and off, but doing so
mjr 17:ab3cec0c8bf4 451 // will have no effect. The reason we leave some ports unassigned
mjr 17:ab3cec0c8bf4 452 // is that we don't have enough physical GPIO pins to fill out the
mjr 17:ab3cec0c8bf4 453 // full LedWiz complement of 32 ports. Many pins are already taken
mjr 17:ab3cec0c8bf4 454 // for other purposes, such as button inputs or the plunger CCD
mjr 17:ab3cec0c8bf4 455 // interface.
mjr 17:ab3cec0c8bf4 456 //
mjr 17:ab3cec0c8bf4 457 // The mapping between physical output pins on the KL25Z and the
mjr 17:ab3cec0c8bf4 458 // assigned LED-Wiz port numbers is essentially arbitrary - you can
mjr 17:ab3cec0c8bf4 459 // customize this by changing the entries in the array below if you
mjr 17:ab3cec0c8bf4 460 // wish to rearrange the pins for any reason. Be aware that some
mjr 17:ab3cec0c8bf4 461 // of the physical outputs are already used for other purposes
mjr 17:ab3cec0c8bf4 462 // (e.g., some of the GPIO pins on header J10 are used for the
mjr 17:ab3cec0c8bf4 463 // CCD sensor - but you can of course reassign those as well by
mjr 17:ab3cec0c8bf4 464 // changing the corresponding declarations elsewhere in this module).
mjr 17:ab3cec0c8bf4 465 // The assignments we make here have two main objectives: first,
mjr 17:ab3cec0c8bf4 466 // to group the outputs on headers J1 and J2 (to facilitate neater
mjr 17:ab3cec0c8bf4 467 // wiring by keeping the output pins together physically), and
mjr 17:ab3cec0c8bf4 468 // second, to make the physical pin layout match the LED-Wiz port
mjr 17:ab3cec0c8bf4 469 // numbering order to the extent possible. There's one big wrench
mjr 17:ab3cec0c8bf4 470 // in the works, though, which is the limited number and discontiguous
mjr 17:ab3cec0c8bf4 471 // placement of the KL25Z PWM-capable output pins. This prevents
mjr 17:ab3cec0c8bf4 472 // us from doing the most obvious sequential ordering of the pins,
mjr 17:ab3cec0c8bf4 473 // so we end up with the outputs arranged into several blocks.
mjr 17:ab3cec0c8bf4 474 // Hopefully this isn't too confusing; for more detailed rationale,
mjr 17:ab3cec0c8bf4 475 // read on...
mjr 17:ab3cec0c8bf4 476 //
mjr 17:ab3cec0c8bf4 477 // With the LED-Wiz, the host software configuration usually
mjr 17:ab3cec0c8bf4 478 // assumes that each RGB LED is hooked up to three consecutive ports
mjr 17:ab3cec0c8bf4 479 // (for the red, green, and blue components, which need to be
mjr 17:ab3cec0c8bf4 480 // physically wired to separate outputs to allow each color to be
mjr 17:ab3cec0c8bf4 481 // controlled independently). To facilitate this, we arrange the
mjr 17:ab3cec0c8bf4 482 // PWM-enabled outputs so that they're grouped together in the
mjr 17:ab3cec0c8bf4 483 // port numbering scheme. Unfortunately, these outputs aren't
mjr 17:ab3cec0c8bf4 484 // together in a single group in the physical pin layout, so to
mjr 17:ab3cec0c8bf4 485 // group them logically in the LED-Wiz port numbering scheme, we
mjr 17:ab3cec0c8bf4 486 // have to break up the overall numbering scheme into several blocks.
mjr 17:ab3cec0c8bf4 487 // So our port numbering goes sequentially down each column of
mjr 17:ab3cec0c8bf4 488 // header pins, but there are several break points where we have
mjr 17:ab3cec0c8bf4 489 // to interrupt the obvious sequence to keep the PWM pins grouped
mjr 17:ab3cec0c8bf4 490 // logically.
mjr 17:ab3cec0c8bf4 491 //
mjr 17:ab3cec0c8bf4 492 // In the list below, "pin J1-2" refers to pin 2 on header J1 on
mjr 17:ab3cec0c8bf4 493 // the KL25Z, using the standard pin numbering in the KL25Z
mjr 17:ab3cec0c8bf4 494 // documentation - this is the physical pin that the port controls.
mjr 17:ab3cec0c8bf4 495 // "LW port 1" means LED-Wiz port 1 - this is the LED-Wiz port
mjr 17:ab3cec0c8bf4 496 // number that you use on the PC side (in the DirectOutput config
mjr 17:ab3cec0c8bf4 497 // file, for example) to address the port. PWM-capable ports are
mjr 17:ab3cec0c8bf4 498 // marked as such - we group the PWM-capable ports into the first
mjr 17:ab3cec0c8bf4 499 // 10 LED-Wiz port numbers.
mjr 17:ab3cec0c8bf4 500 //
mjr 17:ab3cec0c8bf4 501 // If you wish to reallocate a pin in the array below to some other
mjr 17:ab3cec0c8bf4 502 // use, such as a button input port, simply change the pin name in
mjr 17:ab3cec0c8bf4 503 // the entry to NC (for Not Connected). This will disable the given
mjr 17:ab3cec0c8bf4 504 // logical LedWiz port number and free up the physical pin.
mjr 17:ab3cec0c8bf4 505 //
mjr 17:ab3cec0c8bf4 506 // If you wish to reallocate a pin currently assigned to the button
mjr 17:ab3cec0c8bf4 507 // input array, simply change the entry for the pin in the buttonMap[]
mjr 17:ab3cec0c8bf4 508 // array above to NC (for "not connected"), and plug the pin name into
mjr 17:ab3cec0c8bf4 509 // a slot of your choice in the array below.
mjr 17:ab3cec0c8bf4 510 //
mjr 17:ab3cec0c8bf4 511 // Note: PTD1 (pin J2-12) should NOT be assigned as an LedWiz output,
mjr 17:ab3cec0c8bf4 512 // as this pin is physically connected on the KL25Z to the on-board
mjr 17:ab3cec0c8bf4 513 // indicator LED's blue segment. This precludes any other use of
mjr 17:ab3cec0c8bf4 514 // the pin.
mjr 17:ab3cec0c8bf4 515 //
mjr 17:ab3cec0c8bf4 516 struct {
mjr 17:ab3cec0c8bf4 517 PinName pin;
mjr 17:ab3cec0c8bf4 518 bool isPWM;
mjr 17:ab3cec0c8bf4 519 } ledWizPortMap[32] = {
mjr 17:ab3cec0c8bf4 520 { PTA1, true }, // pin J1-2, LW port 1 (PWM capable - TPM 2.0 = channel 9)
mjr 17:ab3cec0c8bf4 521 { PTA2, true }, // pin J1-4, LW port 2 (PWM capable - TPM 2.1 = channel 10)
mjr 17:ab3cec0c8bf4 522 { PTD4, true }, // pin J1-6, LW port 3 (PWM capable - TPM 0.4 = channel 5)
mjr 17:ab3cec0c8bf4 523 { PTA12, true }, // pin J1-8, LW port 4 (PWM capable - TPM 1.0 = channel 7)
mjr 17:ab3cec0c8bf4 524 { PTA4, true }, // pin J1-10, LW port 5 (PWM capable - TPM 0.1 = channel 2)
mjr 17:ab3cec0c8bf4 525 { PTA5, true }, // pin J1-12, LW port 6 (PWM capable - TPM 0.2 = channel 3)
mjr 17:ab3cec0c8bf4 526 { PTA13, true }, // pin J2-2, LW port 7 (PWM capable - TPM 1.1 = channel 13)
mjr 17:ab3cec0c8bf4 527 { PTD5, true }, // pin J2-4, LW port 8 (PWM capable - TPM 0.5 = channel 6)
mjr 17:ab3cec0c8bf4 528 { PTD0, true }, // pin J2-6, LW port 9 (PWM capable - TPM 0.0 = channel 1)
mjr 17:ab3cec0c8bf4 529 { PTD3, true }, // pin J2-10, LW port 10 (PWM capable - TPM 0.3 = channel 4)
mjr 17:ab3cec0c8bf4 530 { PTD2, false }, // pin J2-8, LW port 11
mjr 17:ab3cec0c8bf4 531 { PTC8, false }, // pin J1-14, LW port 12
mjr 17:ab3cec0c8bf4 532 { PTC9, false }, // pin J1-16, LW port 13
mjr 17:ab3cec0c8bf4 533 { PTC7, false }, // pin J1-1, LW port 14
mjr 17:ab3cec0c8bf4 534 { PTC0, false }, // pin J1-3, LW port 15
mjr 17:ab3cec0c8bf4 535 { PTC3, false }, // pin J1-5, LW port 16
mjr 17:ab3cec0c8bf4 536 { PTC4, false }, // pin J1-7, LW port 17
mjr 17:ab3cec0c8bf4 537 { PTC5, false }, // pin J1-9, LW port 18
mjr 17:ab3cec0c8bf4 538 { PTC6, false }, // pin J1-11, LW port 19
mjr 17:ab3cec0c8bf4 539 { PTC10, false }, // pin J1-13, LW port 20
mjr 17:ab3cec0c8bf4 540 { PTC11, false }, // pin J1-15, LW port 21
mjr 17:ab3cec0c8bf4 541 { PTE0, false }, // pin J2-18, LW port 22
mjr 25:e22b88bd783a 542 { NC, false }, // Not connected, LW port 23
mjr 25:e22b88bd783a 543 { NC, false }, // Not connected, LW port 24
mjr 25:e22b88bd783a 544 { NC, false }, // Not connected, LW port 25
mjr 25:e22b88bd783a 545 { NC, false }, // Not connected, LW port 26
mjr 25:e22b88bd783a 546 { NC, false }, // Not connected, LW port 27
mjr 25:e22b88bd783a 547 { NC, false }, // Not connected, LW port 28
mjr 25:e22b88bd783a 548 { NC, false }, // Not connected, LW port 29
mjr 25:e22b88bd783a 549 { NC, false }, // Not connected, LW port 30
mjr 25:e22b88bd783a 550 { NC, false }, // Not connected, LW port 31
mjr 25:e22b88bd783a 551 { NC, false } // Not connected, LW port 32
mjr 17:ab3cec0c8bf4 552 };
mjr 17:ab3cec0c8bf4 553
mjr 21:5048e16cc9ef 554
mjr 25:e22b88bd783a 555 #endif // DECL_EXTERNS