Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

cfgVarMsgMap.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 40:cc0d9814522b 1 // Define the configuration variable USB get/set mapper. We use
mjr 40:cc0d9814522b 2 // macros for the get/set operations to allow for common source
mjr 40:cc0d9814522b 3 // code for the two operations. main.cpp #includes this file twice:
mjr 40:cc0d9814522b 4 // once for the SET function and once for the GET function. main.cpp
mjr 40:cc0d9814522b 5 // redefines the v_xxx macros according to the current inclusion mode.
mjr 40:cc0d9814522b 6 //
mjr 40:cc0d9814522b 7 // This is a little tricky to follow because of the macros, but the
mjr 40:cc0d9814522b 8 // benefit is that the get and set functions automatically stay in
mjr 40:cc0d9814522b 9 // sync in terms of the variable types and byte mappings in the USB
mjr 40:cc0d9814522b 10 // messages, since they're both generated automatically from the
mjr 40:cc0d9814522b 11 // same code.
mjr 40:cc0d9814522b 12 //
mjr 40:cc0d9814522b 13 // The SET function is called directly from the corresponding USB
mjr 40:cc0d9814522b 14 // protocol message to set one variable. The data buffer is simply
mjr 40:cc0d9814522b 15 // the data passed in from the USB message.
mjr 40:cc0d9814522b 16 //
mjr 40:cc0d9814522b 17 // The GET function is called in a loop from our configuration
mjr 40:cc0d9814522b 18 // variable reporting function. The report function loops through
mjr 40:cc0d9814522b 19 // each variable in turn to generate a series of reports. The
mjr 40:cc0d9814522b 20 // caller in this case fills in data[1] with the variable ID, and
mjr 40:cc0d9814522b 21 // it also fills in data[2] with the current index being queried
mjr 40:cc0d9814522b 22 // for the array variables (buttons, outputs). We fill in the
mjr 40:cc0d9814522b 23 // rest of the data[] bytes with the current variable value(s),
mjr 40:cc0d9814522b 24 // encoded for the USB protocol message.
mjr 40:cc0d9814522b 25
mjr 40:cc0d9814522b 26
mjr 76:7f5912b6340e 27 void v_func
mjr 40:cc0d9814522b 28 {
mjr 40:cc0d9814522b 29 switch (data[1])
mjr 40:cc0d9814522b 30 {
mjr 61:3c7e6e9ec355 31 // ********** UNRECOGNIZED VARIABLE IDs **********
mjr 61:3c7e6e9ec355 32 // For any variable ID we don't recognize, we'll ignore SET
mjr 61:3c7e6e9ec355 33 // requests and return all zeroes on QUERY requests. This
mjr 61:3c7e6e9ec355 34 // provides sensible default behavior if a newer version of
mjr 61:3c7e6e9ec355 35 // the config tool is used with an older version of the
mjr 61:3c7e6e9ec355 36 // firwmare. Because of the default all-zero query response,
mjr 61:3c7e6e9ec355 37 // new variable added over time should use zero values as
mjr 61:3c7e6e9ec355 38 // the standard defaults whenever possible. Note that the
mjr 61:3c7e6e9ec355 39 // config tool can also use QUERY VARIABLE 0 to determine
mjr 61:3c7e6e9ec355 40 // the number of variables supported by the firmware it's
mjr 61:3c7e6e9ec355 41 // talking to, if it needs to know whether or not a
mjr 61:3c7e6e9ec355 42 // particular variable exists (a variable exists if its ID
mjr 61:3c7e6e9ec355 43 // is within the range returned by the QUERY 0 call).
mjr 61:3c7e6e9ec355 44 //
mjr 61:3c7e6e9ec355 45 default:
mjr 61:3c7e6e9ec355 46 break;
mjr 61:3c7e6e9ec355 47
mjr 61:3c7e6e9ec355 48
mjr 53:9b2611964afc 49 // ********** DESCRIBE CONFIGURATION VARIABLES **********
mjr 53:9b2611964afc 50 case 0:
mjr 100:1ff35c07217c 51 v_byte_ro(22, 2); // number of SCALAR variables
mjr 77:0b96f6867312 52 v_byte_ro(6, 3); // number of ARRAY variables
mjr 53:9b2611964afc 53 break;
mjr 53:9b2611964afc 54
mjr 53:9b2611964afc 55 // ********** SCALAR VARIABLES **********
mjr 53:9b2611964afc 56
mjr 40:cc0d9814522b 57 case 1:
mjr 40:cc0d9814522b 58 // USB identification (Vendor ID, Product ID)
mjr 40:cc0d9814522b 59 v_ui16(usbVendorID, 2);
mjr 40:cc0d9814522b 60 v_ui16(usbProductID, 4);
mjr 40:cc0d9814522b 61 break;
mjr 40:cc0d9814522b 62
mjr 40:cc0d9814522b 63 case 2:
mjr 40:cc0d9814522b 64 // Pinscape Controller unit number (nominal unit number, 1-16)
mjr 40:cc0d9814522b 65 if_msg_valid(data[2] >= 1 && data[2] <= 16)
mjr 40:cc0d9814522b 66 v_byte(psUnitNo, 2);
mjr 40:cc0d9814522b 67 break;
mjr 40:cc0d9814522b 68
mjr 40:cc0d9814522b 69 case 3:
mjr 92:f264fbaa1be5 70 // Joystick report settings
mjr 40:cc0d9814522b 71 v_byte(joystickEnabled, 2);
mjr 90:aa4e571da8e8 72 v_byte(joystickAxisFormat, 3);
mjr 92:f264fbaa1be5 73 v_ui32(jsReportInterval_us, 4);
mjr 92:f264fbaa1be5 74
mjr 92:f264fbaa1be5 75 #if VAR_MODE_SET
mjr 92:f264fbaa1be5 76 // apply a default if the report interval is zero
mjr 92:f264fbaa1be5 77 if (cfg.jsReportInterval_us == 0)
mjr 92:f264fbaa1be5 78 cfg.jsReportInterval_us = 8333;
mjr 92:f264fbaa1be5 79 #endif
mjr 40:cc0d9814522b 80 break;
mjr 40:cc0d9814522b 81
mjr 40:cc0d9814522b 82 case 4:
mjr 78:1e00b3fa11af 83 // Accelerometer options
mjr 78:1e00b3fa11af 84 v_byte(accel.orientation, 2);
mjr 78:1e00b3fa11af 85 v_byte(accel.range, 3);
mjr 78:1e00b3fa11af 86 v_byte(accel.autoCenterTime, 4);
mjr 92:f264fbaa1be5 87 v_byte(accel.stutter, 5);
mjr 40:cc0d9814522b 88 break;
mjr 40:cc0d9814522b 89
mjr 40:cc0d9814522b 90 case 5:
mjr 40:cc0d9814522b 91 // Plunger sensor type
mjr 40:cc0d9814522b 92 v_byte(plunger.sensorType, 2);
mjr 113:7330439f2ffc 93 v_byte(plunger.param1, 3);
mjr 40:cc0d9814522b 94 break;
mjr 40:cc0d9814522b 95
mjr 40:cc0d9814522b 96 case 6:
mjr 40:cc0d9814522b 97 // Plunger sensor pin assignments
mjr 53:9b2611964afc 98 v_byte(plunger.sensorPin[0], 2);
mjr 53:9b2611964afc 99 v_byte(plunger.sensorPin[1], 3);
mjr 53:9b2611964afc 100 v_byte(plunger.sensorPin[2], 4);
mjr 53:9b2611964afc 101 v_byte(plunger.sensorPin[3], 5);
mjr 40:cc0d9814522b 102 break;
mjr 40:cc0d9814522b 103
mjr 40:cc0d9814522b 104 case 7:
mjr 40:cc0d9814522b 105 // Plunger calibration button and indicator light pin assignments
mjr 55:4db125cd11a0 106 v_byte(plunger.cal.features, 2);
mjr 55:4db125cd11a0 107 v_byte(plunger.cal.btn, 3);
mjr 55:4db125cd11a0 108 v_byte(plunger.cal.led, 4);
mjr 40:cc0d9814522b 109 break;
mjr 40:cc0d9814522b 110
mjr 40:cc0d9814522b 111 case 8:
mjr 40:cc0d9814522b 112 // ZB Launch Ball setup
mjr 40:cc0d9814522b 113 v_byte(plunger.zbLaunchBall.port, 2);
mjr 53:9b2611964afc 114 v_byte(plunger.zbLaunchBall.keytype, 3);
mjr 53:9b2611964afc 115 v_byte(plunger.zbLaunchBall.keycode, 4);
mjr 53:9b2611964afc 116 v_ui16(plunger.zbLaunchBall.pushDistance, 5);
mjr 40:cc0d9814522b 117 break;
mjr 40:cc0d9814522b 118
mjr 40:cc0d9814522b 119 case 9:
mjr 40:cc0d9814522b 120 // TV ON setup
mjr 53:9b2611964afc 121 v_byte(TVON.statusPin, 2);
mjr 53:9b2611964afc 122 v_byte(TVON.latchPin, 3);
mjr 53:9b2611964afc 123 v_byte(TVON.relayPin, 4);
mjr 40:cc0d9814522b 124 v_ui16(TVON.delayTime, 5);
mjr 40:cc0d9814522b 125 break;
mjr 40:cc0d9814522b 126
mjr 40:cc0d9814522b 127 case 10:
mjr 40:cc0d9814522b 128 // TLC5940NT PWM controller chip setup
mjr 40:cc0d9814522b 129 v_byte(tlc5940.nchips, 2);
mjr 53:9b2611964afc 130 v_byte(tlc5940.sin, 3);
mjr 53:9b2611964afc 131 v_byte(tlc5940.sclk, 4);
mjr 53:9b2611964afc 132 v_byte(tlc5940.xlat, 5);
mjr 53:9b2611964afc 133 v_byte(tlc5940.blank, 6);
mjr 53:9b2611964afc 134 v_byte(tlc5940.gsclk, 7);
mjr 40:cc0d9814522b 135 break;
mjr 40:cc0d9814522b 136
mjr 40:cc0d9814522b 137 case 11:
mjr 40:cc0d9814522b 138 // 74HC595 shift register chip setup
mjr 40:cc0d9814522b 139 v_byte(hc595.nchips, 2);
mjr 53:9b2611964afc 140 v_byte(hc595.sin, 3);
mjr 53:9b2611964afc 141 v_byte(hc595.sclk, 4);
mjr 53:9b2611964afc 142 v_byte(hc595.latch, 5);
mjr 53:9b2611964afc 143 v_byte(hc595.ena, 6);
mjr 40:cc0d9814522b 144 break;
mjr 40:cc0d9814522b 145
mjr 40:cc0d9814522b 146 case 12:
mjr 53:9b2611964afc 147 // Disconnect reboot timeout
mjr 53:9b2611964afc 148 v_byte(disconnectRebootTimeout, 2);
mjr 53:9b2611964afc 149 break;
mjr 53:9b2611964afc 150
mjr 53:9b2611964afc 151 case 13:
mjr 53:9b2611964afc 152 // plunger calibration
mjr 53:9b2611964afc 153 v_ui16(plunger.cal.zero, 2);
mjr 53:9b2611964afc 154 v_ui16(plunger.cal.max, 4);
mjr 53:9b2611964afc 155 v_byte(plunger.cal.tRelease, 6);
mjr 74:822a92bc11d2 156 v_byte(plunger.cal.calibrated, 7);
mjr 53:9b2611964afc 157 break;
mjr 53:9b2611964afc 158
mjr 53:9b2611964afc 159 case 14:
mjr 53:9b2611964afc 160 // expansion board configuration
mjr 53:9b2611964afc 161 v_byte(expan.typ, 2);
mjr 53:9b2611964afc 162 v_byte(expan.vsn, 3);
mjr 53:9b2611964afc 163 v_byte(expan.ext[0], 4);
mjr 53:9b2611964afc 164 v_byte(expan.ext[1], 5);
mjr 53:9b2611964afc 165 v_byte(expan.ext[2], 6);
mjr 115:39d2eb4b1830 166 v_byte(expan.ext[3], 7);
mjr 53:9b2611964afc 167 break;
mjr 53:9b2611964afc 168
mjr 53:9b2611964afc 169 case 15:
mjr 53:9b2611964afc 170 // night mode configuration
mjr 53:9b2611964afc 171 v_byte(nightMode.btn, 2);
mjr 53:9b2611964afc 172 v_byte(nightMode.flags, 3);
mjr 53:9b2611964afc 173 v_byte(nightMode.port, 4);
mjr 53:9b2611964afc 174 break;
mjr 53:9b2611964afc 175
mjr 66:2e3583fbd2f4 176 case 16:
mjr 66:2e3583fbd2f4 177 // shift button configuration
mjr 78:1e00b3fa11af 178 v_byte(shiftButton.idx, 2);
mjr 78:1e00b3fa11af 179 v_byte(shiftButton.mode, 3);
mjr 66:2e3583fbd2f4 180 break;
mjr 66:2e3583fbd2f4 181
mjr 77:0b96f6867312 182 case 17:
mjr 77:0b96f6867312 183 // IR sensor and emitter setup
mjr 77:0b96f6867312 184 v_byte(IR.sensor, 2);
mjr 77:0b96f6867312 185 v_byte(IR.emitter, 3);
mjr 77:0b96f6867312 186 break;
mjr 77:0b96f6867312 187
mjr 82:4f6209cb5c33 188 case 18:
mjr 82:4f6209cb5c33 189 // plunger auto-zeroing time
mjr 82:4f6209cb5c33 190 v_byte(plunger.autoZero.flags, 2);
mjr 82:4f6209cb5c33 191 v_byte(plunger.autoZero.t, 3);
mjr 82:4f6209cb5c33 192 break;
mjr 82:4f6209cb5c33 193
mjr 85:3c28aee81cde 194 case 19:
mjr 91:ae9be42652bf 195 // Plunger filters - jitter window size, reversed orientation.
mjr 91:ae9be42652bf 196 // The reversed orientation byte always has bit 0x80 set to indicate
mjr 91:ae9be42652bf 197 // that the feature is supported in this version.
mjr 85:3c28aee81cde 198 v_ui16(plunger.jitterWindow, 2);
mjr 91:ae9be42652bf 199 v_byte_ro(cfg.plunger.reverseOrientation | 0x80, 4);
mjr 91:ae9be42652bf 200 v_byte_wo(plunger.reverseOrientation, 4);
mjr 85:3c28aee81cde 201 break;
mjr 85:3c28aee81cde 202
mjr 87:8d35c74403af 203 case 20:
mjr 87:8d35c74403af 204 // bar-code plunger setup
mjr 87:8d35c74403af 205 v_ui16(plunger.barCode.startPix, 2);
mjr 87:8d35c74403af 206 break;
mjr 87:8d35c74403af 207
mjr 87:8d35c74403af 208 case 21:
mjr 100:1ff35c07217c 209 // TLC59116 PWM controller setup
mjr 87:8d35c74403af 210 v_ui16(tlc59116.chipMask, 2);
mjr 87:8d35c74403af 211 v_byte(tlc59116.sda, 4);
mjr 87:8d35c74403af 212 v_byte(tlc59116.scl, 5);
mjr 87:8d35c74403af 213 v_byte(tlc59116.reset, 6);
mjr 87:8d35c74403af 214 break;
mjr 87:8d35c74403af 215
mjr 100:1ff35c07217c 216 case 22:
mjr 100:1ff35c07217c 217 // plunger raw configuration
mjr 100:1ff35c07217c 218 v_ui16(plunger.cal.raw0, 2);
mjr 100:1ff35c07217c 219 v_ui16(plunger.cal.raw1, 4);
mjr 100:1ff35c07217c 220 v_ui16(plunger.cal.raw2, 6);
mjr 100:1ff35c07217c 221 break;
mjr 100:1ff35c07217c 222
mjr 74:822a92bc11d2 223 // case N: // new scalar variable
mjr 53:9b2611964afc 224 //
mjr 74:822a92bc11d2 225 // !!! ATTENTION !!!
mjr 53:9b2611964afc 226 // UPDATE CASE 0 ABOVE WHEN ADDING A NEW VARIABLE!!!
mjr 66:2e3583fbd2f4 227
mjr 66:2e3583fbd2f4 228
mjr 74:822a92bc11d2 229 // ********** SPECIAL DIAGNOSTIC VARIBLES **********
mjr 74:822a92bc11d2 230 //
mjr 74:822a92bc11d2 231 // This is a set of variables that act like the array variables
mjr 74:822a92bc11d2 232 // below. However, these are generally read-only, and since they
mjr 74:822a92bc11d2 233 // don't contain restorable configuration data, they're not
mjr 74:822a92bc11d2 234 // included in the variable counts reported by a "variable 0"
mjr 74:822a92bc11d2 235 // query above.
mjr 74:822a92bc11d2 236 case 220:
mjr 76:7f5912b6340e 237 #if !VAR_MODE_SET && ENABLE_DIAGNOSTICS
mjr 74:822a92bc11d2 238 {
mjr 74:822a92bc11d2 239 uint32_t a;
mjr 74:822a92bc11d2 240 switch (data[2])
mjr 74:822a92bc11d2 241 {
mjr 74:822a92bc11d2 242 case 1:
mjr 74:822a92bc11d2 243 // main loop, average iteration time in us
mjr 76:7f5912b6340e 244 a = uint32_t(mainLoopIterTime/mainLoopIterCount);
mjr 74:822a92bc11d2 245 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 246 break;
mjr 74:822a92bc11d2 247
mjr 74:822a92bc11d2 248 case 2:
mjr 74:822a92bc11d2 249 // incoming message average processing time in us
mjr 76:7f5912b6340e 250 a = uint32_t(mainLoopMsgTime/mainLoopMsgCount);
mjr 74:822a92bc11d2 251 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 252 break;
mjr 74:822a92bc11d2 253
mjr 74:822a92bc11d2 254 case 3:
mjr 74:822a92bc11d2 255 // PWM update polling routine, average time per call in us
mjr 76:7f5912b6340e 256 a = uint32_t(polledPwmTotalTime/polledPwmRunCount);
mjr 74:822a92bc11d2 257 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 258 break;
mjr 74:822a92bc11d2 259
mjr 74:822a92bc11d2 260 case 4:
mjr 74:822a92bc11d2 261 // LedWiz flash update routine, average time per call in us
mjr 76:7f5912b6340e 262 a = uint32_t(wizPulseTotalTime/wizPulseRunCount);
mjr 74:822a92bc11d2 263 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 264 break;
mjr 76:7f5912b6340e 265
mjr 76:7f5912b6340e 266 case 5:
mjr 76:7f5912b6340e 267 case 6:
mjr 76:7f5912b6340e 268 case 7:
mjr 76:7f5912b6340e 269 case 8:
mjr 76:7f5912b6340e 270 case 9:
mjr 76:7f5912b6340e 271 case 10:
mjr 76:7f5912b6340e 272 case 11:
mjr 76:7f5912b6340e 273 case 12:
mjr 76:7f5912b6340e 274 case 13:
mjr 76:7f5912b6340e 275 case 14:
mjr 76:7f5912b6340e 276 case 15:
mjr 76:7f5912b6340e 277 case 16:
mjr 76:7f5912b6340e 278 // main loop checkpoint N, time in us
mjr 76:7f5912b6340e 279 a = uint32_t(mainLoopIterCheckpt[data[2]-5]/mainLoopIterCount);
mjr 76:7f5912b6340e 280 v_ui32_ro(a, 3);
mjr 76:7f5912b6340e 281 break;
mjr 76:7f5912b6340e 282
mjr 76:7f5912b6340e 283 case 30:
mjr 76:7f5912b6340e 284 a = (plungerSensor != 0 ? plungerSensor->getAvgScanTime() : 0);
mjr 76:7f5912b6340e 285 v_ui32_ro(a, 3);
mjr 76:7f5912b6340e 286 break;
mjr 74:822a92bc11d2 287 }
mjr 74:822a92bc11d2 288 }
mjr 74:822a92bc11d2 289 #endif
mjr 74:822a92bc11d2 290 break;
mjr 53:9b2611964afc 291
mjr 74:822a92bc11d2 292 // ********** ARRAY VARIABLES **********
mjr 53:9b2611964afc 293
mjr 66:2e3583fbd2f4 294
mjr 74:822a92bc11d2 295 // case N: // new array variable
mjr 53:9b2611964afc 296 //
mjr 74:822a92bc11d2 297 // !!! ATTENTION !!!
mjr 53:9b2611964afc 298 // UPDATE CASE 0 ABOVE WHEN ADDING A NEW ARRAY VARIABLE!!!
mjr 66:2e3583fbd2f4 299
mjr 77:0b96f6867312 300 case 250:
mjr 77:0b96f6867312 301 // IR command code - high 32 bits
mjr 77:0b96f6867312 302 {
mjr 77:0b96f6867312 303 int idx = data[2];
mjr 77:0b96f6867312 304 if (idx == 0)
mjr 77:0b96f6867312 305 {
mjr 77:0b96f6867312 306 v_byte_ro(MAX_IR_CODES, 3);
mjr 77:0b96f6867312 307 }
mjr 77:0b96f6867312 308 else if (idx > 0 && idx <= MAX_IR_CODES)
mjr 77:0b96f6867312 309 {
mjr 77:0b96f6867312 310 --idx;
mjr 77:0b96f6867312 311 v_ui32(IRCommand[idx].code.hi, 3);
mjr 77:0b96f6867312 312 }
mjr 77:0b96f6867312 313 }
mjr 77:0b96f6867312 314 break;
mjr 77:0b96f6867312 315
mjr 77:0b96f6867312 316 case 251:
mjr 77:0b96f6867312 317 // IR command code - protocol and low 32 bits
mjr 77:0b96f6867312 318 {
mjr 77:0b96f6867312 319 int idx = data[2];
mjr 77:0b96f6867312 320 if (idx == 0)
mjr 77:0b96f6867312 321 {
mjr 77:0b96f6867312 322 v_byte_ro(MAX_IR_CODES, 3);
mjr 77:0b96f6867312 323 }
mjr 77:0b96f6867312 324 else if (idx > 0 && idx <= MAX_IR_CODES)
mjr 77:0b96f6867312 325 {
mjr 77:0b96f6867312 326 --idx;
mjr 77:0b96f6867312 327 v_byte(IRCommand[idx].protocol, 3);
mjr 77:0b96f6867312 328 v_ui32(IRCommand[idx].code.lo, 4);
mjr 77:0b96f6867312 329 }
mjr 77:0b96f6867312 330 }
mjr 77:0b96f6867312 331 break;
mjr 77:0b96f6867312 332
mjr 77:0b96f6867312 333 case 252:
mjr 77:0b96f6867312 334 // IR command descriptor
mjr 77:0b96f6867312 335 {
mjr 77:0b96f6867312 336 int idx = data[2];
mjr 77:0b96f6867312 337 if (idx == 0)
mjr 77:0b96f6867312 338 {
mjr 77:0b96f6867312 339 v_byte_ro(MAX_IR_CODES, 3);
mjr 77:0b96f6867312 340 }
mjr 77:0b96f6867312 341 else if (idx > 0 && idx <= MAX_IR_CODES)
mjr 77:0b96f6867312 342 {
mjr 77:0b96f6867312 343 --idx;
mjr 77:0b96f6867312 344 v_byte(IRCommand[idx].flags, 3);
mjr 77:0b96f6867312 345 v_byte(IRCommand[idx].keytype, 4);
mjr 77:0b96f6867312 346 v_byte(IRCommand[idx].keycode, 5);
mjr 77:0b96f6867312 347 }
mjr 77:0b96f6867312 348 }
mjr 77:0b96f6867312 349 break;
mjr 77:0b96f6867312 350
mjr 66:2e3583fbd2f4 351 case 253:
mjr 66:2e3583fbd2f4 352 // extended button setup
mjr 66:2e3583fbd2f4 353 {
mjr 66:2e3583fbd2f4 354 // get the index and check if it's in range
mjr 66:2e3583fbd2f4 355 int idx = data[2];
mjr 66:2e3583fbd2f4 356 if (idx == 0)
mjr 66:2e3583fbd2f4 357 {
mjr 66:2e3583fbd2f4 358 // index 0 on query retrieves number of slots
mjr 66:2e3583fbd2f4 359 v_byte_ro(MAX_BUTTONS, 3);
mjr 66:2e3583fbd2f4 360 }
mjr 66:2e3583fbd2f4 361 else if (idx > 0 && idx <= MAX_BUTTONS)
mjr 66:2e3583fbd2f4 362 {
mjr 66:2e3583fbd2f4 363 // adjust to an array index
mjr 66:2e3583fbd2f4 364 --idx;
mjr 66:2e3583fbd2f4 365
mjr 66:2e3583fbd2f4 366 // transfer the values
mjr 66:2e3583fbd2f4 367 v_byte(button[idx].typ2, 3);
mjr 66:2e3583fbd2f4 368 v_byte(button[idx].val2, 4);
mjr 77:0b96f6867312 369 v_byte(button[idx].IRCommand2, 5);
mjr 66:2e3583fbd2f4 370 }
mjr 66:2e3583fbd2f4 371 }
mjr 66:2e3583fbd2f4 372 break;
mjr 74:822a92bc11d2 373
mjr 53:9b2611964afc 374 case 254:
mjr 40:cc0d9814522b 375 // button setup
mjr 40:cc0d9814522b 376 {
mjr 40:cc0d9814522b 377 // get the button number
mjr 40:cc0d9814522b 378 int idx = data[2];
mjr 40:cc0d9814522b 379
mjr 40:cc0d9814522b 380 // if it's in range, set the button data
mjr 53:9b2611964afc 381 if (idx == 0)
mjr 53:9b2611964afc 382 {
mjr 53:9b2611964afc 383 // index 0 on query retrieves number of slots
mjr 65:739875521aae 384 v_byte_ro(MAX_BUTTONS, 3);
mjr 53:9b2611964afc 385 }
mjr 65:739875521aae 386 else if (idx > 0 && idx <= MAX_BUTTONS)
mjr 40:cc0d9814522b 387 {
mjr 40:cc0d9814522b 388 // adjust to an array index
mjr 40:cc0d9814522b 389 --idx;
mjr 40:cc0d9814522b 390
mjr 66:2e3583fbd2f4 391 // transfer the values
mjr 40:cc0d9814522b 392 v_byte(button[idx].pin, 3);
mjr 40:cc0d9814522b 393 v_byte(button[idx].typ, 4);
mjr 40:cc0d9814522b 394 v_byte(button[idx].val, 5);
mjr 40:cc0d9814522b 395 v_byte(button[idx].flags, 6);
mjr 77:0b96f6867312 396 v_byte(button[idx].IRCommand, 7);
mjr 40:cc0d9814522b 397 }
mjr 40:cc0d9814522b 398 }
mjr 40:cc0d9814522b 399 break;
mjr 40:cc0d9814522b 400
mjr 53:9b2611964afc 401 case 255:
mjr 40:cc0d9814522b 402 // LedWiz output port setup
mjr 40:cc0d9814522b 403 {
mjr 40:cc0d9814522b 404 // get the port number
mjr 40:cc0d9814522b 405 int idx = data[2];
mjr 40:cc0d9814522b 406
mjr 40:cc0d9814522b 407 // if it's in range, set the port data
mjr 53:9b2611964afc 408 if (idx == 0)
mjr 53:9b2611964afc 409 {
mjr 53:9b2611964afc 410 // index 0 on query retrieves number of slots
mjr 53:9b2611964afc 411 v_byte_ro(MAX_OUT_PORTS, 3);
mjr 53:9b2611964afc 412 }
mjr 53:9b2611964afc 413 else if (idx > 0 && idx <= MAX_OUT_PORTS)
mjr 40:cc0d9814522b 414 {
mjr 40:cc0d9814522b 415 // adjust to an array index
mjr 40:cc0d9814522b 416 --idx;
mjr 40:cc0d9814522b 417
mjr 40:cc0d9814522b 418 // set the values
mjr 40:cc0d9814522b 419 v_byte(outPort[idx].typ, 3);
mjr 40:cc0d9814522b 420 v_byte(outPort[idx].pin, 4);
mjr 40:cc0d9814522b 421 v_byte(outPort[idx].flags, 5);
mjr 89:c43cd923401c 422 v_byte(outPort[idx].flipperLogic, 6);
mjr 40:cc0d9814522b 423 }
mjr 40:cc0d9814522b 424 }
mjr 40:cc0d9814522b 425 break;
mjr 40:cc0d9814522b 426 }
mjr 40:cc0d9814522b 427 }
mjr 40:cc0d9814522b 428