Arnaud VALLEY / Mbed 2 deprecated Pinscape_Controller_V2_arnoz

Mirror with some correction

Dependencies:   mbed FastIO FastPWM USBDevice

cfgVarMsgMap.h@78:1e00b3fa11af, 2017-03-19 (annotated)

Committer:
mjr
Date:
Sun Mar 19 05:30:53 2017 +0000
Revision:
78:1e00b3fa11af
Parent:
77:0b96f6867312
Child:
82:4f6209cb5c33
Ad hoc IR command send; Shift button 'AND' and 'OR' modes; new accelerometer auto centering options

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 77:0b96f6867312 51 v_byte_ro(17, 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 40:cc0d9814522b 70 // Enable/disable joystick
mjr 40:cc0d9814522b 71 v_byte(joystickEnabled, 2);
mjr 40:cc0d9814522b 72 break;
mjr 40:cc0d9814522b 73
mjr 40:cc0d9814522b 74 case 4:
mjr 78:1e00b3fa11af 75 // Accelerometer options
mjr 78:1e00b3fa11af 76 v_byte(accel.orientation, 2);
mjr 78:1e00b3fa11af 77 v_byte(accel.range, 3);
mjr 78:1e00b3fa11af 78 v_byte(accel.autoCenterTime, 4);
mjr 40:cc0d9814522b 79 break;
mjr 40:cc0d9814522b 80
mjr 40:cc0d9814522b 81 case 5:
mjr 40:cc0d9814522b 82 // Plunger sensor type
mjr 40:cc0d9814522b 83 v_byte(plunger.sensorType, 2);
mjr 40:cc0d9814522b 84 break;
mjr 40:cc0d9814522b 85
mjr 40:cc0d9814522b 86 case 6:
mjr 40:cc0d9814522b 87 // Plunger sensor pin assignments
mjr 53:9b2611964afc 88 v_byte(plunger.sensorPin[0], 2);
mjr 53:9b2611964afc 89 v_byte(plunger.sensorPin[1], 3);
mjr 53:9b2611964afc 90 v_byte(plunger.sensorPin[2], 4);
mjr 53:9b2611964afc 91 v_byte(plunger.sensorPin[3], 5);
mjr 40:cc0d9814522b 92 break;
mjr 40:cc0d9814522b 93
mjr 40:cc0d9814522b 94 case 7:
mjr 40:cc0d9814522b 95 // Plunger calibration button and indicator light pin assignments
mjr 55:4db125cd11a0 96 v_byte(plunger.cal.features, 2);
mjr 55:4db125cd11a0 97 v_byte(plunger.cal.btn, 3);
mjr 55:4db125cd11a0 98 v_byte(plunger.cal.led, 4);
mjr 40:cc0d9814522b 99 break;
mjr 40:cc0d9814522b 100
mjr 40:cc0d9814522b 101 case 8:
mjr 40:cc0d9814522b 102 // ZB Launch Ball setup
mjr 40:cc0d9814522b 103 v_byte(plunger.zbLaunchBall.port, 2);
mjr 53:9b2611964afc 104 v_byte(plunger.zbLaunchBall.keytype, 3);
mjr 53:9b2611964afc 105 v_byte(plunger.zbLaunchBall.keycode, 4);
mjr 53:9b2611964afc 106 v_ui16(plunger.zbLaunchBall.pushDistance, 5);
mjr 40:cc0d9814522b 107 break;
mjr 40:cc0d9814522b 108
mjr 40:cc0d9814522b 109 case 9:
mjr 40:cc0d9814522b 110 // TV ON setup
mjr 53:9b2611964afc 111 v_byte(TVON.statusPin, 2);
mjr 53:9b2611964afc 112 v_byte(TVON.latchPin, 3);
mjr 53:9b2611964afc 113 v_byte(TVON.relayPin, 4);
mjr 40:cc0d9814522b 114 v_ui16(TVON.delayTime, 5);
mjr 40:cc0d9814522b 115 break;
mjr 40:cc0d9814522b 116
mjr 40:cc0d9814522b 117 case 10:
mjr 40:cc0d9814522b 118 // TLC5940NT PWM controller chip setup
mjr 40:cc0d9814522b 119 v_byte(tlc5940.nchips, 2);
mjr 53:9b2611964afc 120 v_byte(tlc5940.sin, 3);
mjr 53:9b2611964afc 121 v_byte(tlc5940.sclk, 4);
mjr 53:9b2611964afc 122 v_byte(tlc5940.xlat, 5);
mjr 53:9b2611964afc 123 v_byte(tlc5940.blank, 6);
mjr 53:9b2611964afc 124 v_byte(tlc5940.gsclk, 7);
mjr 40:cc0d9814522b 125 break;
mjr 40:cc0d9814522b 126
mjr 40:cc0d9814522b 127 case 11:
mjr 40:cc0d9814522b 128 // 74HC595 shift register chip setup
mjr 40:cc0d9814522b 129 v_byte(hc595.nchips, 2);
mjr 53:9b2611964afc 130 v_byte(hc595.sin, 3);
mjr 53:9b2611964afc 131 v_byte(hc595.sclk, 4);
mjr 53:9b2611964afc 132 v_byte(hc595.latch, 5);
mjr 53:9b2611964afc 133 v_byte(hc595.ena, 6);
mjr 40:cc0d9814522b 134 break;
mjr 40:cc0d9814522b 135
mjr 40:cc0d9814522b 136 case 12:
mjr 53:9b2611964afc 137 // Disconnect reboot timeout
mjr 53:9b2611964afc 138 v_byte(disconnectRebootTimeout, 2);
mjr 53:9b2611964afc 139 break;
mjr 53:9b2611964afc 140
mjr 53:9b2611964afc 141 case 13:
mjr 53:9b2611964afc 142 // plunger calibration
mjr 53:9b2611964afc 143 v_ui16(plunger.cal.zero, 2);
mjr 53:9b2611964afc 144 v_ui16(plunger.cal.max, 4);
mjr 53:9b2611964afc 145 v_byte(plunger.cal.tRelease, 6);
mjr 74:822a92bc11d2 146 v_byte(plunger.cal.calibrated, 7);
mjr 53:9b2611964afc 147 break;
mjr 53:9b2611964afc 148
mjr 53:9b2611964afc 149 case 14:
mjr 53:9b2611964afc 150 // expansion board configuration
mjr 53:9b2611964afc 151 v_byte(expan.typ, 2);
mjr 53:9b2611964afc 152 v_byte(expan.vsn, 3);
mjr 53:9b2611964afc 153 v_byte(expan.ext[0], 4);
mjr 53:9b2611964afc 154 v_byte(expan.ext[1], 5);
mjr 53:9b2611964afc 155 v_byte(expan.ext[2], 6);
mjr 53:9b2611964afc 156 break;
mjr 53:9b2611964afc 157
mjr 53:9b2611964afc 158 case 15:
mjr 53:9b2611964afc 159 // night mode configuration
mjr 53:9b2611964afc 160 v_byte(nightMode.btn, 2);
mjr 53:9b2611964afc 161 v_byte(nightMode.flags, 3);
mjr 53:9b2611964afc 162 v_byte(nightMode.port, 4);
mjr 53:9b2611964afc 163 break;
mjr 53:9b2611964afc 164
mjr 66:2e3583fbd2f4 165 case 16:
mjr 66:2e3583fbd2f4 166 // shift button configuration
mjr 78:1e00b3fa11af 167 v_byte(shiftButton.idx, 2);
mjr 78:1e00b3fa11af 168 v_byte(shiftButton.mode, 3);
mjr 66:2e3583fbd2f4 169 break;
mjr 66:2e3583fbd2f4 170
mjr 77:0b96f6867312 171 case 17:
mjr 77:0b96f6867312 172 // IR sensor and emitter setup
mjr 77:0b96f6867312 173 v_byte(IR.sensor, 2);
mjr 77:0b96f6867312 174 v_byte(IR.emitter, 3);
mjr 77:0b96f6867312 175 break;
mjr 77:0b96f6867312 176
mjr 74:822a92bc11d2 177 // case N: // new scalar variable
mjr 53:9b2611964afc 178 //
mjr 74:822a92bc11d2 179 // !!! ATTENTION !!!
mjr 53:9b2611964afc 180 // UPDATE CASE 0 ABOVE WHEN ADDING A NEW VARIABLE!!!
mjr 66:2e3583fbd2f4 181
mjr 66:2e3583fbd2f4 182
mjr 74:822a92bc11d2 183 // ********** SPECIAL DIAGNOSTIC VARIBLES **********
mjr 74:822a92bc11d2 184 //
mjr 74:822a92bc11d2 185 // This is a set of variables that act like the array variables
mjr 74:822a92bc11d2 186 // below. However, these are generally read-only, and since they
mjr 74:822a92bc11d2 187 // don't contain restorable configuration data, they're not
mjr 74:822a92bc11d2 188 // included in the variable counts reported by a "variable 0"
mjr 74:822a92bc11d2 189 // query above.
mjr 74:822a92bc11d2 190 case 220:
mjr 76:7f5912b6340e 191 #if !VAR_MODE_SET && ENABLE_DIAGNOSTICS
mjr 74:822a92bc11d2 192 {
mjr 74:822a92bc11d2 193 uint32_t a;
mjr 74:822a92bc11d2 194 switch (data[2])
mjr 74:822a92bc11d2 195 {
mjr 74:822a92bc11d2 196 case 1:
mjr 74:822a92bc11d2 197 // main loop, average iteration time in us
mjr 76:7f5912b6340e 198 a = uint32_t(mainLoopIterTime/mainLoopIterCount);
mjr 74:822a92bc11d2 199 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 200 break;
mjr 74:822a92bc11d2 201
mjr 74:822a92bc11d2 202 case 2:
mjr 74:822a92bc11d2 203 // incoming message average processing time in us
mjr 76:7f5912b6340e 204 a = uint32_t(mainLoopMsgTime/mainLoopMsgCount);
mjr 74:822a92bc11d2 205 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 206 break;
mjr 74:822a92bc11d2 207
mjr 74:822a92bc11d2 208 case 3:
mjr 74:822a92bc11d2 209 // PWM update polling routine, average time per call in us
mjr 76:7f5912b6340e 210 a = uint32_t(polledPwmTotalTime/polledPwmRunCount);
mjr 74:822a92bc11d2 211 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 212 break;
mjr 74:822a92bc11d2 213
mjr 74:822a92bc11d2 214 case 4:
mjr 74:822a92bc11d2 215 // LedWiz flash update routine, average time per call in us
mjr 76:7f5912b6340e 216 a = uint32_t(wizPulseTotalTime/wizPulseRunCount);
mjr 74:822a92bc11d2 217 v_ui32_ro(a, 3);
mjr 74:822a92bc11d2 218 break;
mjr 76:7f5912b6340e 219
mjr 76:7f5912b6340e 220 case 5:
mjr 76:7f5912b6340e 221 case 6:
mjr 76:7f5912b6340e 222 case 7:
mjr 76:7f5912b6340e 223 case 8:
mjr 76:7f5912b6340e 224 case 9:
mjr 76:7f5912b6340e 225 case 10:
mjr 76:7f5912b6340e 226 case 11:
mjr 76:7f5912b6340e 227 case 12:
mjr 76:7f5912b6340e 228 case 13:
mjr 76:7f5912b6340e 229 case 14:
mjr 76:7f5912b6340e 230 case 15:
mjr 76:7f5912b6340e 231 case 16:
mjr 76:7f5912b6340e 232 // main loop checkpoint N, time in us
mjr 76:7f5912b6340e 233 a = uint32_t(mainLoopIterCheckpt[data[2]-5]/mainLoopIterCount);
mjr 76:7f5912b6340e 234 v_ui32_ro(a, 3);
mjr 76:7f5912b6340e 235 break;
mjr 76:7f5912b6340e 236
mjr 76:7f5912b6340e 237 case 30:
mjr 76:7f5912b6340e 238 a = (plungerSensor != 0 ? plungerSensor->getAvgScanTime() : 0);
mjr 76:7f5912b6340e 239 v_ui32_ro(a, 3);
mjr 76:7f5912b6340e 240 break;
mjr 74:822a92bc11d2 241 }
mjr 74:822a92bc11d2 242 }
mjr 74:822a92bc11d2 243 #endif
mjr 74:822a92bc11d2 244 break;
mjr 53:9b2611964afc 245
mjr 74:822a92bc11d2 246 // ********** ARRAY VARIABLES **********
mjr 53:9b2611964afc 247
mjr 66:2e3583fbd2f4 248
mjr 74:822a92bc11d2 249 // case N: // new array variable
mjr 53:9b2611964afc 250 //
mjr 74:822a92bc11d2 251 // !!! ATTENTION !!!
mjr 53:9b2611964afc 252 // UPDATE CASE 0 ABOVE WHEN ADDING A NEW ARRAY VARIABLE!!!
mjr 66:2e3583fbd2f4 253
mjr 77:0b96f6867312 254 case 250:
mjr 77:0b96f6867312 255 // IR command code - high 32 bits
mjr 77:0b96f6867312 256 {
mjr 77:0b96f6867312 257 int idx = data[2];
mjr 77:0b96f6867312 258 if (idx == 0)
mjr 77:0b96f6867312 259 {
mjr 77:0b96f6867312 260 v_byte_ro(MAX_IR_CODES, 3);
mjr 77:0b96f6867312 261 }
mjr 77:0b96f6867312 262 else if (idx > 0 && idx <= MAX_IR_CODES)
mjr 77:0b96f6867312 263 {
mjr 77:0b96f6867312 264 --idx;
mjr 77:0b96f6867312 265 v_ui32(IRCommand[idx].code.hi, 3);
mjr 77:0b96f6867312 266 }
mjr 77:0b96f6867312 267 }
mjr 77:0b96f6867312 268 break;
mjr 77:0b96f6867312 269
mjr 77:0b96f6867312 270 case 251:
mjr 77:0b96f6867312 271 // IR command code - protocol and low 32 bits
mjr 77:0b96f6867312 272 {
mjr 77:0b96f6867312 273 int idx = data[2];
mjr 77:0b96f6867312 274 if (idx == 0)
mjr 77:0b96f6867312 275 {
mjr 77:0b96f6867312 276 v_byte_ro(MAX_IR_CODES, 3);
mjr 77:0b96f6867312 277 }
mjr 77:0b96f6867312 278 else if (idx > 0 && idx <= MAX_IR_CODES)
mjr 77:0b96f6867312 279 {
mjr 77:0b96f6867312 280 --idx;
mjr 77:0b96f6867312 281 v_byte(IRCommand[idx].protocol, 3);
mjr 77:0b96f6867312 282 v_ui32(IRCommand[idx].code.lo, 4);
mjr 77:0b96f6867312 283 }
mjr 77:0b96f6867312 284 }
mjr 77:0b96f6867312 285 break;
mjr 77:0b96f6867312 286
mjr 77:0b96f6867312 287 case 252:
mjr 77:0b96f6867312 288 // IR command descriptor
mjr 77:0b96f6867312 289 {
mjr 77:0b96f6867312 290 int idx = data[2];
mjr 77:0b96f6867312 291 if (idx == 0)
mjr 77:0b96f6867312 292 {
mjr 77:0b96f6867312 293 v_byte_ro(MAX_IR_CODES, 3);
mjr 77:0b96f6867312 294 }
mjr 77:0b96f6867312 295 else if (idx > 0 && idx <= MAX_IR_CODES)
mjr 77:0b96f6867312 296 {
mjr 77:0b96f6867312 297 --idx;
mjr 77:0b96f6867312 298 v_byte(IRCommand[idx].flags, 3);
mjr 77:0b96f6867312 299 v_byte(IRCommand[idx].keytype, 4);
mjr 77:0b96f6867312 300 v_byte(IRCommand[idx].keycode, 5);
mjr 77:0b96f6867312 301 }
mjr 77:0b96f6867312 302 }
mjr 77:0b96f6867312 303 break;
mjr 77:0b96f6867312 304
mjr 66:2e3583fbd2f4 305 case 253:
mjr 66:2e3583fbd2f4 306 // extended button setup
mjr 66:2e3583fbd2f4 307 {
mjr 66:2e3583fbd2f4 308 // get the index and check if it's in range
mjr 66:2e3583fbd2f4 309 int idx = data[2];
mjr 66:2e3583fbd2f4 310 if (idx == 0)
mjr 66:2e3583fbd2f4 311 {
mjr 66:2e3583fbd2f4 312 // index 0 on query retrieves number of slots
mjr 66:2e3583fbd2f4 313 v_byte_ro(MAX_BUTTONS, 3);
mjr 66:2e3583fbd2f4 314 }
mjr 66:2e3583fbd2f4 315 else if (idx > 0 && idx <= MAX_BUTTONS)
mjr 66:2e3583fbd2f4 316 {
mjr 66:2e3583fbd2f4 317 // adjust to an array index
mjr 66:2e3583fbd2f4 318 --idx;
mjr 66:2e3583fbd2f4 319
mjr 66:2e3583fbd2f4 320 // transfer the values
mjr 66:2e3583fbd2f4 321 v_byte(button[idx].typ2, 3);
mjr 66:2e3583fbd2f4 322 v_byte(button[idx].val2, 4);
mjr 77:0b96f6867312 323 v_byte(button[idx].IRCommand2, 5);
mjr 66:2e3583fbd2f4 324 }
mjr 66:2e3583fbd2f4 325 }
mjr 66:2e3583fbd2f4 326 break;
mjr 74:822a92bc11d2 327
mjr 53:9b2611964afc 328 case 254:
mjr 40:cc0d9814522b 329 // button setup
mjr 40:cc0d9814522b 330 {
mjr 40:cc0d9814522b 331 // get the button number
mjr 40:cc0d9814522b 332 int idx = data[2];
mjr 40:cc0d9814522b 333
mjr 40:cc0d9814522b 334 // if it's in range, set the button data
mjr 53:9b2611964afc 335 if (idx == 0)
mjr 53:9b2611964afc 336 {
mjr 53:9b2611964afc 337 // index 0 on query retrieves number of slots
mjr 65:739875521aae 338 v_byte_ro(MAX_BUTTONS, 3);
mjr 53:9b2611964afc 339 }
mjr 65:739875521aae 340 else if (idx > 0 && idx <= MAX_BUTTONS)
mjr 40:cc0d9814522b 341 {
mjr 40:cc0d9814522b 342 // adjust to an array index
mjr 40:cc0d9814522b 343 --idx;
mjr 40:cc0d9814522b 344
mjr 66:2e3583fbd2f4 345 // transfer the values
mjr 40:cc0d9814522b 346 v_byte(button[idx].pin, 3);
mjr 40:cc0d9814522b 347 v_byte(button[idx].typ, 4);
mjr 40:cc0d9814522b 348 v_byte(button[idx].val, 5);
mjr 40:cc0d9814522b 349 v_byte(button[idx].flags, 6);
mjr 77:0b96f6867312 350 v_byte(button[idx].IRCommand, 7);
mjr 40:cc0d9814522b 351 }
mjr 40:cc0d9814522b 352 }
mjr 40:cc0d9814522b 353 break;
mjr 40:cc0d9814522b 354
mjr 53:9b2611964afc 355 case 255:
mjr 40:cc0d9814522b 356 // LedWiz output port setup
mjr 40:cc0d9814522b 357 {
mjr 40:cc0d9814522b 358 // get the port number
mjr 40:cc0d9814522b 359 int idx = data[2];
mjr 40:cc0d9814522b 360
mjr 40:cc0d9814522b 361 // if it's in range, set the port data
mjr 53:9b2611964afc 362 if (idx == 0)
mjr 53:9b2611964afc 363 {
mjr 53:9b2611964afc 364 // index 0 on query retrieves number of slots
mjr 53:9b2611964afc 365 v_byte_ro(MAX_OUT_PORTS, 3);
mjr 53:9b2611964afc 366 }
mjr 53:9b2611964afc 367 else if (idx > 0 && idx <= MAX_OUT_PORTS)
mjr 40:cc0d9814522b 368 {
mjr 40:cc0d9814522b 369 // adjust to an array index
mjr 40:cc0d9814522b 370 --idx;
mjr 40:cc0d9814522b 371
mjr 40:cc0d9814522b 372 // set the values
mjr 40:cc0d9814522b 373 v_byte(outPort[idx].typ, 3);
mjr 40:cc0d9814522b 374 v_byte(outPort[idx].pin, 4);
mjr 40:cc0d9814522b 375 v_byte(outPort[idx].flags, 5);
mjr 40:cc0d9814522b 376 }
mjr 40:cc0d9814522b 377 }
mjr 40:cc0d9814522b 378 break;
mjr 40:cc0d9814522b 379 }
mjr 40:cc0d9814522b 380 }
mjr 40:cc0d9814522b 381