From 8f9f7fa21b948a03e076e7a6a6dc91bc9eb701f7 Mon Sep 17 00:00:00 2001 From: Hans-Christoph Steiner Date: Fri, 2 Jun 2006 20:06:51 +0000 Subject: ripped out old method of get events and build whole new method which should use a lot less CPU; its now based on arrays of structs that are built before running. There is a 2D array for (device,element) struct, t_hid_element, which holds the output symbols, thus eliminating symbol lookups for each event that is outputted; its Mac OS X only write now, GNU/Linux will come eventually... svn path=/trunk/externals/hcs/hid/; revision=5156 --- Makefile | 4 + TODO | 116 +++- doc/hid-help.pd | 424 ++++++------ hid.c | 72 +- hid.h | 44 +- hid_darwin.c | 1991 +++++++++++++++++++++++++++---------------------------- hid_linux.c | 8 +- 7 files changed, 1405 insertions(+), 1254 deletions(-) diff --git a/Makefile b/Makefile index a13265f..f474aee 100644 --- a/Makefile +++ b/Makefile @@ -13,3 +13,7 @@ clean: test_locations: make -C $(EXTERNALS_ROOT) test_locations +# for emacs +etags: + etags *.[ch] linux/input.h HID\ Utilities\ Source/*.[ch] \ + /System/Library/Frameworks/IOKit.framework/Headers/hid*/*.[ch] diff --git a/TODO b/TODO index 66a26dd..4cf35cf 100644 --- a/TODO +++ b/TODO @@ -1,6 +1,57 @@ +- fix up hatswitch logic... hmmm + on Mac OS X, just make the next element in the array always be the Y axis of + the hatswitch, then when receiving a hatswitch event, output, increment, + then output again (yes, its a hack). -============================================================================== +- add device type to [info( +HIDGetUsageName(pCurrentHIDDevice->usagePage, pCurrentHIDDevice->usage, cstrDeviceName); + +i.e. cstrDeviceName + + + + +______________________________________________________________________________ += array lookups for symbols + +- make arrays to lookup symbols by usagepage# and usage# + +- advantage: much fewer symbol lookups + +- disadvantage: much more RAM used. + +implementation idea #1: + +make hid-specific gensym() function which checks an array for the symbol by +#. If it doesn't exist, it looks up the symbol and adds it to the array. The +array size should be dynamically allocated so that [hid] doesn't use massive +amounts of memory. + +If no vendor-defined pages are used, then the array could be quite small. If +only one usage page is used, then it would also be not too big. Otherwise, it +could use 10+ megs of RAM... hmm.. + +implementation idea #2: + +this array should be built by hid_build_elements_list(). Then each time it +fetches an event using the element_pointer array, it would also get the stored +usage_page and usage symbols, and instance t_float. So I need to make an +element struct like: + +struct _hid_element +{ + void *element; + t_symbol *type; // HID "usage page" + t_symbol *usage; // Linux "code" + t_float instance; + t_float previous_value; //only output on change on abs and buttons +} t_hid_element; + +For Linux input.h, instead void *element, store the type and code numbers to +compare against + +______________________________________________________________________________ = output one value per poll - for relative axes, sum up all events and output one @@ -11,10 +62,18 @@ http://lists.apple.com/archives/mac-games-dev/2005/Oct/msg00060.html - buttons, output everything -- is this at all necessary? How often do multiple events happen in one poll period? +- is this at all necessary? How often do multiple events happen in one poll + period? ANSWER: on Mac OS X, most hid_get_events() calls fetch multiple + events for each mouse axis, so yes, its probably necessary -============================================================================== +______________________________________________________________________________ += [poll 1( message set to exact delay based on block size + +to eliminate the jitter of the messages being processed every block, have +[poll 1( set the time to the poll size (~1.5ms for 44,100) + +______________________________________________________________________________ = iterate through elements and do a proper queue of the ones we want: - also, label multiple instances of the same usage @@ -22,11 +81,11 @@ http://lists.apple.com/archives/mac-games-dev/2005/Oct/msg00060.html http://mud.5341.com/msg/8455.html -============================================================================== +______________________________________________________________________________ = make second inlet for poll # (for [human->pd]) -============================================================================== +______________________________________________________________________________ = output device data on open - Logical Min/Max i.e. [range -127 127( @@ -34,13 +93,13 @@ http://mud.5341.com/msg/8455.html -============================================================================== +______________________________________________________________________________ = open devices by name i.e "Trackpad" a la Max's [hi] -============================================================================== +______________________________________________________________________________ = = autoscaling based on Logical min/max @@ -49,9 +108,9 @@ i.e "Trackpad" a la Max's [hi] - output would be handy, rather than autoscale, to save on CPU +- this should probably be done in Pd space - -============================================================================== +______________________________________________________________________________ = test verbose names - matju says symbols are compared by pointer, so they are fast @@ -75,13 +134,13 @@ i.e "Trackpad" a la Max's [hi] - change word "code" to "element" -============================================================================== +______________________________________________________________________________ = event name changes - make key/button Type "button" rather than "key" (undecided on this one) -============================================================================== +______________________________________________________________________________ = hid/serial - open/close status outlet @@ -91,7 +150,7 @@ i.e "Trackpad" a la Max's [hi] - [tgl] 1/0 for open/close -============================================================================== +______________________________________________________________________________ = linux input synch events (EV_SYN) - these seem to be generated by the Linux kernel, so they probably don't fit @@ -100,21 +159,26 @@ i.e "Trackpad" a la Max's [hi] data, as they are intended. +______________________________________________________________________________ += writing support! + +- Linux example: http://www.linuxjournal.com/article/6429 + -============================================================================== +______________________________________________________________________________ = profile [hid] object and usage - find out if [autoscale] takes a lot of CPU power, or where in [hid] is using CPU where it doesn't have to be -============================================================================== +______________________________________________________________________________ = Report available FF effects - check against HID Utilities Source/PID.h -============================================================================== +______________________________________________________________________________ = pollfn for mouse-like devices - determine whether using a pollfn is actually better than using a t_clock @@ -127,13 +191,13 @@ i.e "Trackpad" a la Max's [hi] - at standard block size (64 samples), one block = ~1.5ms -============================================================================== +______________________________________________________________________________ = function return values - most functions probably do not need return values -============================================================================== +______________________________________________________________________________ = check out using USB timestamp - use the USB timestamp to correctly space the output data (meh, probably @@ -141,11 +205,21 @@ i.e "Trackpad" a la Max's [hi] - /++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\ -++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + /----------------------------------------------------------------------------\ +------------------------------------------------------------------------------ BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS -++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ - \++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/ +------------------------------------------------------------------------------ + \----------------------------------------------------------------------------/ + +______________________________________________________________________________ +- BUG: crashes when you try yo open "mouse" with no args + + +______________________________________________________________________________ +- BUG: on Mac OS X, polling starts without hid_build_device_list() + +- when polling starts, hid_build_device_list() should be called before starting + ______________________________________________________________________________ - BUG: figure out how to prevent segfaults on mismapped devices/elements diff --git a/doc/hid-help.pd b/doc/hid-help.pd index 41b97c2..304fcf9 100644 --- a/doc/hid-help.pd +++ b/doc/hid-help.pd @@ -1,48 +1,45 @@ -#N canvas 242 96 932 657 10; -#X msg 233 353 abs abs_y 55; -#X floatatom 27 484 5 0 0 0 - - -; -#X floatatom 83 484 5 0 0 0 - - -; -#X floatatom 63 440 6 0 0 0 - - -; -#X obj 129 122 tgl 35 0 empty empty empty 0 -6 0 8 -24198 -1 -1 25 -25; -#X floatatom 571 385 12 0 0 1 value - -; -#X symbolatom 531 401 15 0 0 1 event_code - -; -#X symbolatom 492 417 15 0 0 1 event_type - -; +#N canvas 59 45 910 595 10; +#X floatatom 27 454 5 0 0 0 - - -; +#X floatatom 83 454 5 0 0 0 - - -; +#X floatatom 63 410 6 0 0 0 - - -; +#X obj 129 92 tgl 35 0 empty empty empty 0 -6 0 8 -24198 -1 -1 25 25 +; +#X floatatom 571 355 12 0 0 1 value - -; +#X symbolatom 531 371 15 0 0 1 event_code - -; +#X symbolatom 492 387 15 0 0 1 event_type - -; #X obj 2 2 cnv 15 900 20 empty empty [hid] 2 11 1 18 -233017 -66577 0; -#X text 246 368 outlet message format:; -#X obj 772 104 ev-list; -#X obj 772 155 ev_syn-list; -#X obj 772 177 ev_key-list; -#X obj 772 199 ev_rel-list; -#X obj 772 221 ev_abs-list; -#X obj 772 243 ev_msc-list; -#X obj 772 265 ev_led-list; -#X obj 772 287 ev_snd-list; -#X obj 772 309 ev_rep-list; -#X obj 772 331 ev_ff-list; -#X obj 772 353 ev_ff_status-list; -#X text 740 85 Event Types:; -#X text 740 136 Event Codes:; -#X floatatom 138 388 5 0 0 1 ev_syn - -; -#X obj 111 387 +; -#X msg 111 367 1; +#X text 274 347 outlet message format:; +#X obj 772 114 ev-list; +#X obj 772 165 ev_syn-list; +#X obj 772 187 ev_key-list; +#X obj 772 209 ev_rel-list; +#X obj 772 231 ev_abs-list; +#X obj 772 253 ev_msc-list; +#X obj 772 275 ev_led-list; +#X obj 772 297 ev_snd-list; +#X obj 772 319 ev_rep-list; +#X obj 772 341 ev_ff-list; +#X obj 772 363 ev_ff_status-list; +#X text 740 95 Event Types:; +#X text 740 146 Event Codes:; +#X floatatom 138 358 5 0 0 1 ev_syn - -; +#X obj 111 357 +; +#X msg 111 337 1; #X msg 402 117 close; #X msg 402 96 refresh; #X text 463 94 refresh device list; -#X text 537 532 For more info:; -#X text 49 588 (C) Copyright 2004 Hans-Christoph Steiner -; -#X text 266 602 released under the GNU GPL; -#X text 472 589 $Revision: 1.23 $$Date: 2006-05-28 20:13:58 $; -#X text 473 602 $Author: eighthave $; -#X msg 421 266 poll 20; -#X msg 359 266 poll 2; -#X text 355 251 start polling and set the poll delay in ms; -#X text 462 28 !!! This software is very much alpha \, so any aspect +#X text 537 502 For more info:; +#X text 266 572 released under the GNU GPL; +#X text 472 559 $Revision: 1.24 $$Date: 2006-06-02 20:06:51 $; +#X text 473 572 $Author: eighthave $; +#X msg 436 216 poll 20; +#X msg 374 216 poll 2; +#X text 370 201 start polling and set the poll delay in ms; +#X text 462 48 !!! This software is very much alpha \, so any aspect of it could change without notice !!!; -#X obj 16 336 route key rel abs syn; -#X obj 9 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 +#X obj 16 306 route key rel abs syn; +#X obj 9 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 ; #N canvas 278 328 631 544 Event_Codes 0; #X text 28 48 (For a complete listing of Linux Input Events \, see @@ -196,7 +193,7 @@ of it could change without notice !!!; #X text 138 476 BTN_BASE6; #X text 245 463 298; #X text 245 477 299; -#X restore 774 419 pd Event_Codes; +#X restore 774 429 pd Event_Codes; #N canvas 50 289 469 317 Event_Types 0; #X text 28 48 (For a complete listing of Linux Input Events \, see /usr/include/linux/input.h.); @@ -239,101 +236,90 @@ of it could change without notice !!!; #X text 331 255 22; #X text 230 255 EV_PWR; #X text 61 255 Power Events (for UPS); -#X restore 774 399 pd Event_Types; +#X restore 774 409 pd Event_Types; #N canvas 0 22 450 300 Event_Values 0; #X text 28 48 (For a complete listing of Linux Input Events \, see /usr/include/linux/input.h.); #X obj 11 9 cnv 15 400 30 empty empty Event_Values 20 12 1 14 -261681 -66577 0; -#X restore 774 439 pd Event_Values; -#X floatatom 140 484 5 0 0 0 - - -; -#X obj 421 439 route abs_hat0x abs_hat0y abs_hat1x abs_hat1y; -#X floatatom 421 461 7 0 0 0 - - -; -#X msg 179 121 1; -#X msg 179 141 0; +#X restore 774 449 pd Event_Values; +#X floatatom 140 454 5 0 0 0 - - -; +#X obj 421 409 route abs_hat0x abs_hat0y abs_hat1x abs_hat1y; +#X floatatom 421 431 7 0 0 0 - - -; #X msg 402 138 print; -#X obj 304 295 hid 0; +#X obj 304 265 hid 0; #X text 465 118 close the device; #X text 465 139 print the device and element lists; -#X text 9 257 Any non-zero value starts polling \,; -#X text 8 270 0 stops the polling. If the number; -#X text 9 283 is greater than 1 \, then the poll; -#X text 9 296 delay is set to that number.; -#X msg 489 266 poll 2000; -#X obj 27 464 route rel_x rel_y rel_z rel_wheel; -#X floatatom 196 484 5 0 0 0 - - -; -#X obj 492 366 unpack s s f; -#X msg 203 68 open \$1; -#X obj 203 50 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 --1 2; -#X floatatom 190 71 1 0 0 0 - - -; -#X text 270 382 event_type event_code value; -#X obj 63 419 route abs_x abs_y abs_z abs_rx abs_ry abs_rz abs_throttle +#X text 9 227 Any non-zero value starts polling \,; +#X text 8 240 0 stops the polling. If the number; +#X text 9 253 is greater than 1 \, then the poll; +#X text 9 266 delay is set to that number.; +#X obj 27 434 route rel_x rel_y rel_z rel_wheel; +#X floatatom 196 454 5 0 0 0 - - -; +#X obj 492 336 unpack s s f; +#X msg 258 125 open \$1; +#X obj 258 107 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X floatatom 247 126 1 0 0 0 - - -; +#X text 298 361 event_type event_code value; +#X obj 63 389 route abs_x abs_y abs_z abs_rx abs_ry abs_rz abs_throttle ; -#X obj 421 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +#X obj 421 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 -1; -#X floatatom 498 461 7 0 0 0 - - -; -#X obj 498 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +#X floatatom 498 431 7 0 0 0 - - -; +#X obj 498 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1; -#X floatatom 576 461 7 0 0 0 - - -; -#X obj 576 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +#X floatatom 576 431 7 0 0 0 - - -; +#X obj 576 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1; -#X floatatom 653 461 7 0 0 0 - - -; -#X obj 653 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +#X floatatom 653 431 7 0 0 0 - - -; +#X obj 653 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1; -#X floatatom 113 440 6 0 0 0 - - -; -#X floatatom 163 440 6 0 0 0 - - -; -#X floatatom 213 440 6 0 0 0 - - -; -#X floatatom 263 440 6 0 0 0 - - -; -#X floatatom 313 440 6 0 0 0 - - -; -#X floatatom 363 440 6 0 0 0 - - -; -#X obj 39 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 +#X floatatom 113 410 6 0 0 0 - - -; +#X floatatom 163 410 6 0 0 0 - - -; +#X floatatom 213 410 6 0 0 0 - - -; +#X floatatom 263 410 6 0 0 0 - - -; +#X floatatom 313 410 6 0 0 0 - - -; +#X floatatom 363 410 6 0 0 0 - - -; +#X obj 39 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 ; -#X obj 69 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 +#X obj 69 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 ; -#X obj 99 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 +#X obj 99 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1 ; -#X obj 129 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 129 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 159 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 159 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 189 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 189 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 219 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 219 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 249 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 249 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 279 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 279 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 309 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 309 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 339 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 339 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 369 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 369 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 399 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 399 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 9 505 route btn_0 btn_1 btn_2 btn_3 btn_4 btn_5 btn_6 btn_7 +#X obj 9 475 route btn_0 btn_1 btn_2 btn_3 btn_4 btn_5 btn_6 btn_7 btn_8 btn_9 btn_10 btn_11 btn_12 btn_13 btn_14 btn_15; -#X obj 429 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 429 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 459 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 +#X obj 459 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1; -#X obj 234 334 cyclone/prepend set; -#X msg 37 196 debug \$1; -#X obj 37 174 hradio 15 1 1 10 empty empty empty 0 -6 0 8 -262144 -1 --1 9; -#X obj 646 531 pddp/pddp_open all_about_hid; -#X obj 232 91 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +#X obj 262 313 cyclone/prepend set; +#X msg 37 166 debug \$1; +#X obj 37 144 hradio 15 1 1 10 empty empty empty 0 -6 0 8 -262144 -1 -1 0; -#X msg 233 111 open mouse \$1; -#X text 541 208 Gravis/Destroyer Tiltpad; -#X msg 400 207 open 0x047D 0x4008; -#X obj 253 135 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 --1 0; -#X msg 262 155 open keyboard \$1; -#X msg 298 190 info; -#N canvas 477 37 395 219 see 0; +#X obj 646 501 pddp/pddp_open all_about_hid; +#X msg 298 160 info; +#N canvas 477 37 399 223 see 0; #N canvas 247 287 550 277 route 0; #X obj 53 13 inlet; #X obj 98 225 outlet; @@ -387,95 +373,151 @@ vendorID productID; #X connect 0 7 4 0; #X connect 2 0 0 0; #X connect 2 0 3 0; -#X restore 512 290 pd see device info; -#X msg 397 179 open 0x046d 0xc01d; -#X text 535 179 Logitech USB-PS/2 Optical Mouse; -#N canvas 0 22 458 308 test 1; -#X obj 60 23 inlet; -#X obj 61 53 route not_implemented; -#X obj 65 100 route notimp_64; -#X obj 165 138 print; -#X floatatom 69 146 5 0 0 0 - - -; +#X restore 418 286 pd see device info; +#N canvas 0 22 380 450 open 0; +#X obj 77 61 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X msg 78 81 open mouse \$1; +#X obj 121 201 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X msg 130 221 open keyboard \$1; +#X obj 50 13 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X obj 55 417 outlet; +#X obj 85 108 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X msg 94 128 open joystick \$1; +#X msg 59 33 open pointer \$1; +#X obj 101 155 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X msg 110 175 open gamepad \$1; +#X obj 137 244 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X msg 146 264 open keypad \$1; +#X obj 141 291 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 +-1 0; +#X msg 150 311 open multiaxiscontroller \$1; +#X text 155 342 or just open the first one:; +#X msg 138 363 open mouse; +#X msg 159 381 open joystick; +#X connect 0 0 1 0; +#X connect 1 0 5 0; +#X connect 2 0 3 0; +#X connect 3 0 5 0; +#X connect 4 0 8 0; +#X connect 6 0 7 0; +#X connect 7 0 5 0; +#X connect 8 0 5 0; +#X connect 9 0 10 0; +#X connect 10 0 5 0; +#X connect 11 0 12 0; +#X connect 12 0 5 0; +#X connect 13 0 14 0; +#X connect 14 0 5 0; +#X connect 16 0 5 0; +#X connect 17 0 5 0; +#X restore 203 74 pd open by device type; +#N canvas 88 102 470 320 open 0; +#X text 217 82 Gravis/Destroyer Tiltpad; +#X msg 76 81 open 0x047D 0x4008; +#X msg 73 53 open 0x046d 0xc01d; +#X text 211 53 Logitech USB-PS/2 Optical Mouse; +#X obj 10 277 outlet; +#X text 9 12 You can use the hex values of the USB vendor and product +IDs (it is not case sensitive):; +#X text 221 111 Overtone CUI v1.0; +#X msg 80 110 open 0x1043 0x0015; +#X connect 1 0 4 0; +#X connect 2 0 4 0; +#X connect 7 0 4 0; +#X restore 174 52 pd open by vendor/product ID; +#N canvas 114 93 523 432 test 0; +#X obj 122 5 inlet; +#X obj 66 64 route DESKTOP; +#X obj 65 118 route DESKTOP57; +#X obj 48 167 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1 +-1; +#X floatatom 73 172 5 0 0 0 - - -; +#X obj 126 175 spigot; +#X obj 124 216 print test; +#X obj 167 152 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 +1; #X connect 0 0 1 0; #X connect 1 0 2 0; +#X connect 2 0 3 0; #X connect 2 0 4 0; -#X connect 2 1 3 0; -#X restore 490 330 pd test; -#X obj 36 63 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1 --1 0; -#X msg 45 83 open joystick \$1; -#X connect 4 0 49 0; -#X connect 23 0 24 1; +#X connect 2 0 5 0; +#X connect 5 0 6 0; +#X connect 7 0 5 1; +#X restore 197 318 pd test; +#X msg 504 216 poll 200; +#X msg 261 332 abs abs_y 55; +#X text 49 558 (C) Copyright 2004 Hans-Christoph Steiner +; +#X connect 3 0 45 0; +#X connect 22 0 23 1; +#X connect 23 0 22 0; #X connect 24 0 23 0; -#X connect 25 0 24 0; -#X connect 26 0 49 0; -#X connect 27 0 49 0; -#X connect 34 0 49 0; -#X connect 35 0 49 0; -#X connect 38 0 91 0; -#X connect 38 1 57 0; -#X connect 38 2 64 0; -#X connect 38 3 25 0; +#X connect 25 0 45 0; +#X connect 26 0 45 0; +#X connect 32 0 45 0; +#X connect 33 0 45 0; +#X connect 36 0 86 0; +#X connect 36 1 52 0; +#X connect 36 2 59 0; +#X connect 36 3 24 0; +#X connect 42 0 43 0; +#X connect 42 1 61 0; +#X connect 42 2 63 0; +#X connect 42 3 65 0; +#X connect 43 0 60 0; #X connect 44 0 45 0; -#X connect 44 1 66 0; -#X connect 44 2 68 0; -#X connect 44 3 70 0; -#X connect 45 0 65 0; -#X connect 46 0 49 0; -#X connect 47 0 49 0; -#X connect 48 0 49 0; -#X connect 49 0 38 0; -#X connect 49 0 59 0; -#X connect 49 0 94 0; -#X connect 49 0 108 0; -#X connect 49 1 105 0; -#X connect 56 0 49 0; -#X connect 57 0 1 0; -#X connect 57 1 2 0; -#X connect 57 2 43 0; -#X connect 57 3 58 0; -#X connect 59 0 7 0; -#X connect 59 1 6 0; -#X connect 59 2 5 0; -#X connect 60 0 49 0; -#X connect 61 0 60 0; +#X connect 45 0 36 0; +#X connect 45 0 54 0; +#X connect 45 0 89 0; +#X connect 45 0 97 0; +#X connect 45 1 94 0; +#X connect 52 0 0 0; +#X connect 52 1 1 0; +#X connect 52 2 41 0; +#X connect 52 3 53 0; +#X connect 54 0 6 0; +#X connect 54 1 5 0; +#X connect 54 2 4 0; +#X connect 55 0 45 0; +#X connect 56 0 55 0; +#X connect 56 0 57 0; +#X connect 59 0 2 0; +#X connect 59 1 67 0; +#X connect 59 2 68 0; +#X connect 59 3 69 0; +#X connect 59 4 70 0; +#X connect 59 5 71 0; +#X connect 59 6 72 0; +#X connect 59 7 42 0; #X connect 61 0 62 0; -#X connect 64 0 3 0; -#X connect 64 1 72 0; -#X connect 64 2 73 0; -#X connect 64 3 74 0; -#X connect 64 4 75 0; -#X connect 64 5 76 0; -#X connect 64 6 77 0; -#X connect 64 7 44 0; -#X connect 66 0 67 0; -#X connect 68 0 69 0; -#X connect 70 0 71 0; -#X connect 91 0 39 0; -#X connect 91 1 78 0; -#X connect 91 2 79 0; -#X connect 91 3 80 0; -#X connect 91 4 81 0; -#X connect 91 5 82 0; -#X connect 91 6 83 0; -#X connect 91 7 84 0; -#X connect 91 8 85 0; -#X connect 91 9 86 0; -#X connect 91 10 87 0; -#X connect 91 11 88 0; -#X connect 91 12 89 0; -#X connect 91 13 90 0; -#X connect 91 14 92 0; -#X connect 91 15 93 0; -#X connect 94 0 0 0; -#X connect 95 0 49 0; -#X connect 96 0 95 0; -#X connect 98 0 99 0; -#X connect 99 0 49 0; -#X connect 101 0 49 0; -#X connect 102 0 103 0; -#X connect 103 0 49 0; -#X connect 104 0 49 0; -#X connect 106 0 49 0; -#X connect 109 0 110 0; -#X connect 110 0 49 0; +#X connect 63 0 64 0; +#X connect 65 0 66 0; +#X connect 86 0 37 0; +#X connect 86 1 73 0; +#X connect 86 2 74 0; +#X connect 86 3 75 0; +#X connect 86 4 76 0; +#X connect 86 5 77 0; +#X connect 86 6 78 0; +#X connect 86 7 79 0; +#X connect 86 8 80 0; +#X connect 86 9 81 0; +#X connect 86 10 82 0; +#X connect 86 11 83 0; +#X connect 86 12 84 0; +#X connect 86 13 85 0; +#X connect 86 14 87 0; +#X connect 86 15 88 0; +#X connect 89 0 99 0; +#X connect 90 0 45 0; +#X connect 91 0 90 0; +#X connect 93 0 45 0; +#X connect 95 0 45 0; +#X connect 96 0 45 0; +#X connect 98 0 45 0; diff --git a/hid.c b/hid.c index 741cb4b..7ee4ee8 100644 --- a/hid.c +++ b/hid.c @@ -122,9 +122,9 @@ static unsigned int name_to_usage(char *usage_name) } -static t_int get_device_number_from_arguments(int argc, t_atom *argv) +static short get_device_number_from_arguments(int argc, t_atom *argv) { - t_int device_number = -1; + short device_number = -1; unsigned short usage_number; unsigned int usage; unsigned short vendor_id; @@ -135,11 +135,10 @@ static t_int get_device_number_from_arguments(int argc, t_atom *argv) if(argc == 1) { - post("one arg"); first_argument = atom_getsymbolarg(0,argc,argv); if(first_argument == &s_) { // single float arg means device - device_number = (unsigned short) atom_getfloatarg(0,argc,argv); + device_number = (short) atom_getfloatarg(0,argc,argv); if(device_number < 0) device_number = -1; debug_print(LOG_DEBUG,"[hid] setting device# to %d",device_number); } @@ -164,32 +163,38 @@ static t_int get_device_number_from_arguments(int argc, t_atom *argv) atom_string(argv, usage_string, MAXPDSTRING-1); usage = name_to_usage(usage_string); usage_number = atom_getfloatarg(1,argc,argv); - debug_print(LOG_DEBUG,"[hid] looking for %s at #%d",usage_string,usage_number); + debug_print(LOG_DEBUG,"[hid] looking for %s at #%d", + usage_string,usage_number); device_number = get_device_number_from_usage_list(usage_number, usage >> 16, usage & 0xffff); } else { /* two symbols means idVendor and idProduct in hex */ - vendor_id = (unsigned short) strtol(first_argument->s_name, NULL, 16); - product_id = (unsigned short) strtol(second_argument->s_name, NULL, 16); + vendor_id = + (unsigned short) strtol(first_argument->s_name, NULL, 16); + product_id = + (unsigned short) strtol(second_argument->s_name, NULL, 16); device_number = get_device_number_by_id(vendor_id,product_id); } } return(device_number); } -void hid_output_event(t_hid *x, t_symbol *type, t_symbol *code, t_float value) -{ - t_atom event_data[3]; - - SETSYMBOL(event_data, type); - SETSYMBOL(event_data + 1, code); - SETFLOAT(event_data + 2, value); - outlet_anything(x->x_data_outlet,atom_gensym(event_data),2,event_data+1); +void hid_output_event(t_hid *x, t_hid_element *output_data) +{ + if( (output_data->value != output_data->previous_value) || + (output_data->relative) ) // relative data should always be output + { + t_atom event_data[2]; + SETSYMBOL(event_data, output_data->name); + SETFLOAT(event_data + 1, output_data->value); + outlet_anything(x->x_data_outlet,output_data->type,2,event_data); + } } + /* stop polling the device */ static void stop_poll(t_hid* x) { @@ -212,36 +217,39 @@ void hid_poll(t_hid* x, t_float f) { debug_print(LOG_DEBUG,"hid_poll"); -/* if the user sets the delay less than one, ignore */ - if( f > 0 ) +/* if the user sets the delay less than 2, set to block size */ + if( f > 2 ) x->x_delay = (t_int)f; - - if( (!x->x_device_open) && (x->x_device_number > -1) ) - hid_open(x,gensym("open"),0,NULL); - - if(!x->x_started) + else if( f > 0 ) //TODO make this the actual time between message processing + x->x_delay = 1.54; + if(x->x_device_number > -1) { - clock_delay(x->x_clock, x->x_delay); - debug_print(LOG_DEBUG,"[hid] polling started"); - x->x_started = 1; - } + if(!x->x_device_open) + hid_open(x,gensym("open"),0,NULL); + if(!x->x_started) + { + clock_delay(x->x_clock, x->x_delay); + debug_print(LOG_DEBUG,"[hid] polling started"); + x->x_started = 1; + } + } } static void hid_set_from_float(t_hid *x, t_floatarg f) { /* values greater than 1 set the polling delay time */ /* 1 and 0 for start/stop so you can use a [tgl] */ - if (f > 1) + if(f > 1) { x->x_delay = (t_int)f; hid_poll(x,f); } - else if (f == 1) + else if(f == 1) { - if (! x->x_started) - hid_poll(x,f); + if(! x->x_started) + hid_poll(x,f); } - else if (f == 0) + else if(f == 0) { stop_poll(x); } @@ -280,7 +288,7 @@ static void hid_open(t_hid *x, t_symbol *s, int argc, t_atom *argv) /* store running state to be restored after the device has been opened */ t_int started = x->x_started; - int device_number = get_device_number_from_arguments(argc, argv); + short device_number = get_device_number_from_arguments(argc, argv); if(device_number > -1) { if( (device_number != x->x_device_number) && (x->x_device_open) ) diff --git a/hid.h b/hid.h index b4db8bb..bd31b88 100644 --- a/hid.h +++ b/hid.h @@ -15,7 +15,7 @@ #define HID_MAJOR_VERSION 0 #define HID_MINOR_VERSION 7 -/* static char *version = "$Revision: 1.23 $"; */ +/* static char *version = "$Revision: 1.24 $"; */ /*------------------------------------------------------------------------------ * GLOBAL DEFINES @@ -26,6 +26,13 @@ /* this is set to simplify data structures (arrays instead of linked lists) */ #define MAX_DEVICES 128 +/* think 64 is the limit per device as defined in the OS */ +#define MAX_ELEMENTS 64 + +/* this is limited so that the object doesn't cause a click getting too many + * events from the OS's event queue */ +#define MAX_EVENTS_PER_POLL 64 + /*------------------------------------------------------------------------------ * CLASS DEF */ @@ -33,7 +40,7 @@ typedef struct _hid { t_object x_obj; t_int x_fd; - t_int x_device_number; + short x_device_number; // unsigned short vendor_id; // USB idVendor for current device // unsigned short product_id; // USB idProduct for current device t_int x_has_ff; @@ -64,6 +71,28 @@ extern unsigned short global_debug_level; /* next I need to make a data structure to hold the data to be output for this * poll. This should probably be an array for efficiency */ + +typedef struct _hid_element +{ +#ifdef __linux__ + //GNU/Linux store type and code to compare against +#else + void *os_pointer; // pRecElement on Mac OS X; +#endif /* __linux__ */ + t_symbol *type; // Linux "type"; HID "usagePage" + t_symbol *name; // Linux "code"; HID "usage" + unsigned char polled; // is it polled or queued? (maybe only on Mac OS X?) + unsigned char relative; // relative data gets output everytime + t_float instance; // usage page/usage instance # ([absolute throttle 2 163( + t_int value; // output the sum of events in a poll for relative axes + t_int previous_value; //only output on change on abs and buttons +} t_hid_element; + +/* store element structs to eliminate symbol table lookups, etc. */ +t_hid_element *element[MAX_DEVICES][MAX_ELEMENTS]; +/* number of active elements per device */ +unsigned short element_count[MAX_DEVICES]; + /*------------------------------------------------------------------------------ * FUNCTION PROTOTYPES FOR DIFFERENT PLATFORMS */ @@ -71,20 +100,23 @@ extern unsigned short global_debug_level; /* support functions */ void debug_print(t_int debug_level, const char *fmt, ...); void debug_error(t_hid *x, t_int debug_level, const char *fmt, ...); +void hid_output_event(t_hid *x, t_hid_element *output_data); +/* the old way void hid_output_event(t_hid *x, t_symbol *type, t_symbol *code, t_float value); +*/ /* generic, cross-platform functions implemented in a separate file for each * platform */ -t_int hid_open_device(t_hid *x, t_int device_number); +t_int hid_open_device(t_hid *x, short device_number); t_int hid_close_device(t_hid *x); void hid_build_device_list(void); -t_int hid_get_events(t_hid *x); +void hid_get_events(t_hid *x); void hid_print(t_hid* x); /* print info to the console */ void hid_platform_specific_info(t_hid* x); /* device info on the status outlet */ void hid_platform_specific_free(t_hid *x); -t_int get_device_number_by_id(unsigned short vendor_id, unsigned short product_id); -t_int get_device_number_from_usage_list(t_int device_number, +short get_device_number_by_id(unsigned short vendor_id, unsigned short product_id); +short get_device_number_from_usage_list(short device_number, unsigned short usage_page, unsigned short usage); diff --git a/hid_darwin.c b/hid_darwin.c index 66fe4f1..cfe3319 100644 --- a/hid_darwin.c +++ b/hid_darwin.c @@ -62,9 +62,17 @@ extern t_int hid_instance_count; -/* store device pointers */ +/* store device pointers so I don't have to query them all the time */ pRecDevice device_pointer[MAX_DEVICES]; + +// this stuff is moving to the t_hid_element struct + +/* store element pointers for elements that are not queued (absolute axes) */ +//pRecElement element[MAX_DEVICES][MAX_ELEMENTS]; +/* number of active elements per device */ +//unsigned short element_count[MAX_DEVICES]; + /*============================================================================== * FUNCTION PROTOTYPES *============================================================================== @@ -82,85 +90,148 @@ char *convertEventsFromDarwinToLinux(pRecElement element); * This function is needed to translate the USB HID relative flag into the * [hid]/linux style events */ -void convertAxis(pRecElement element, char *linux_type, char *linux_code, char *axis) +void convert_axis_to_symbols(pRecElement pCurrentHIDElement, t_hid_element *new_element, char *axis) { - if (element->relative) + char buffer[MAXPDSTRING]; + if (pCurrentHIDElement->relative) { - sprintf(linux_type,"rel"); - sprintf(linux_code,"rel_%s",axis); + new_element->type = gensym("rel"); + snprintf(buffer, sizeof(buffer), "rel_%s", axis); + new_element->name = gensym(buffer); } else { - sprintf(linux_type,"abs"); - sprintf(linux_code,"abs_%s",axis); + new_element->type = gensym("abs"); + snprintf(buffer, sizeof(buffer), "abs_%s", axis); + new_element->name = gensym(buffer); } } -void convertDarwinElementToLinuxTypeCode(pRecElement element, char *linux_type, char *linux_code) +void get_usage_symbols(pRecElement pCurrentHIDElement, t_hid_element *new_element) { -// t_int button_offset = 0; +// debug_print(LOG_DEBUG,"get_usage_symbols"); + char buffer[MAXPDSTRING]; - switch(element->type) + if(new_element == NULL) { - case kIOHIDElementTypeInput_Button: - sprintf(linux_type, "key"); - break; + debug_print(LOG_EMERG,"[hid] new_element == NULL!! This is a bug, please report it."); + return; + } + if(pCurrentHIDElement == NULL) + { + debug_print(LOG_EMERG,"[hid] pCurrentHIDElement == NULL!! This is a bug, please report it."); + return; } - switch (element->usagePage) + switch(pCurrentHIDElement->type) { - case kHIDPage_GenericDesktop: - switch (element->usage) - { - case kHIDUsage_GD_X: convertAxis(element, linux_type, linux_code, "x"); break; - case kHIDUsage_GD_Y: convertAxis(element, linux_type, linux_code, "y"); break; - case kHIDUsage_GD_Z: convertAxis(element, linux_type, linux_code, "z"); break; - case kHIDUsage_GD_Rx: convertAxis(element, linux_type, linux_code, "rx"); break; - case kHIDUsage_GD_Ry: convertAxis(element, linux_type, linux_code, "ry"); break; - case kHIDUsage_GD_Rz: convertAxis(element, linux_type, linux_code, "rz"); break; - case kHIDUsage_GD_Wheel: - sprintf(linux_type,"rel");sprintf(linux_code,"rel_wheel");break; - case kHIDUsage_GD_Slider: - sprintf(linux_type,"abs");sprintf(linux_code,"abs_throttle");break; - } + case kIOHIDElementTypeInput_Button: + new_element->type = gensym("key"); + break; + } + switch (pCurrentHIDElement->usagePage) + { + case kHIDPage_GenericDesktop: + switch (pCurrentHIDElement->usage) + { + case kHIDUsage_GD_X: convert_axis_to_symbols(pCurrentHIDElement, new_element, "x"); break; + case kHIDUsage_GD_Y: convert_axis_to_symbols(pCurrentHIDElement, new_element, "y"); break; + case kHIDUsage_GD_Z: convert_axis_to_symbols(pCurrentHIDElement, new_element, "z"); break; + case kHIDUsage_GD_Rx: convert_axis_to_symbols(pCurrentHIDElement, new_element, "rx"); break; + case kHIDUsage_GD_Ry: convert_axis_to_symbols(pCurrentHIDElement, new_element, "ry"); break; + case kHIDUsage_GD_Rz: convert_axis_to_symbols(pCurrentHIDElement, new_element, "rz"); break; + case kHIDUsage_GD_Slider: + new_element->type = gensym("abs"); + new_element->name = gensym("abs_throttle"); break; - case kHIDPage_Simulation: - switch (element->usage) - { - case kHIDUsage_Sim_Rudder: - sprintf(linux_type,"abs");sprintf(linux_code,"abs_rz");break; - case kHIDUsage_Sim_Throttle: - sprintf(linux_type,"abs");sprintf(linux_code,"abs_throttle");break; - } + case kHIDUsage_GD_Dial: + new_element->type = gensym("abs"); + new_element->name = gensym("abs_ry"); break; - case kHIDPage_KeyboardOrKeypad: - sprintf(linux_type, "key"); - /* temporary kludge until I feel like writing the translation table */ - sprintf(linux_code, "key_%ld", element->usage); + case kHIDUsage_GD_Wheel: + new_element->type = gensym("rel"); + new_element->name = gensym("rel_wheel"); break; - case kHIDPage_Button: - sprintf(linux_type, "key"); - /* HID Manager button numbers start at 1, [hid] start at 0 */ - sprintf(linux_code, "btn_%ld", element->usage - 1); + case kHIDUsage_GD_Hatswitch: + // this is still a mystery how to handle + new_element->type = gensym("abs"); + new_element->name = gensym("hatswitch"); break; - case kHIDPage_LEDs: - /* temporary kludge until I feel like writing the translation table */ - sprintf(linux_type, "led"); - sprintf(linux_code, "led_%ld", element->usage); + default: + new_element->type = gensym("DESKTOP"); + snprintf(buffer, sizeof(buffer), "DESKTOP%ld", pCurrentHIDElement->usage); + new_element->name = gensym(buffer); + } + break; + case kHIDPage_Simulation: + switch (pCurrentHIDElement->usage) + { + case kHIDUsage_Sim_Rudder: + new_element->type = gensym("abs"); + new_element->name = gensym("abs_rz"); break; - case kHIDPage_PID: - /* temporary kludge until I feel like writing the translation table */ - sprintf(linux_type, "ff"); - sprintf(linux_code, "ff_%ld", element->usage); + case kHIDUsage_Sim_Throttle: + new_element->type = gensym("abs"); + new_element->name = gensym("abs_throttle"); break; default: - /* temporary kludge until I feel like writing the translation table */ - sprintf(linux_type, "not_implemented"); - sprintf(linux_code, "notimp_%ld", element->usage); + new_element->type = gensym("SIMULATION"); + snprintf(buffer, sizeof(buffer), "SIMULATION%ld", pCurrentHIDElement->usage); + new_element->name = gensym(buffer); + } + break; + case kHIDPage_KeyboardOrKeypad: + new_element->type = gensym("key"); + /* temporary kludge until I feel like writing the translation table */ + snprintf(buffer, sizeof(buffer), "key_%ld", pCurrentHIDElement->usage); + new_element->name = gensym(buffer); + break; + case kHIDPage_Button: + new_element->type = gensym("key"); + /* HID Manager button numbers start at 1, [hid] start at 0 */ + snprintf(buffer, sizeof(buffer), "btn_%ld", pCurrentHIDElement->usage - 1); + new_element->name = gensym(buffer); + break; + case kHIDPage_LEDs: + /* temporary kludge until I feel like writing the translation table */ + new_element->type = gensym("led"); + snprintf(buffer, sizeof(buffer), "led_%ld", pCurrentHIDElement->usage); + new_element->name = gensym(buffer); + break; + case kHIDPage_PID: + /* temporary kludge until I feel like writing the translation table */ + new_element->type = gensym("ff"); + snprintf(buffer, sizeof(buffer), "ff_%ld", pCurrentHIDElement->usage); + new_element->name = gensym(buffer); + break; + default: + /* the rest are "vendor defined" so no translation table is possible */ + snprintf(buffer, sizeof(buffer), "0x%04x", (unsigned int) pCurrentHIDElement->usagePage); + new_element->type = gensym(buffer); + snprintf(buffer, sizeof(buffer), "0x%04x", (unsigned int) pCurrentHIDElement->usage); + new_element->name = gensym(buffer); + } +} + + +static t_float get_type_name_instance(t_symbol *type, t_symbol *name, + int argc, t_hid_element **argv) +{ + int i; + int instance_count = 0; + for(i=0; iname == name) && (argv[i]->type == type) ) + { + ++instance_count; +// post("found %d instances of %s %s", instance_count, type->s_name, name->s_name); + } } + return((t_float) instance_count); } + /* * Linux input events report hatswitches as absolute axes with -1, 0, 1 as * possible values. MacOS X HID Manager reports hatswitches as a specific @@ -169,52 +240,72 @@ void convertDarwinElementToLinuxTypeCode(pRecElement element, char *linux_type, */ /* - * hmm, not sure how to implement this cleanly yet, so I left the code - * inline in hid_get_events(). -void hid_convert_hatswitch_values(IOHIDEventStruct event, char *linux_type, char *linux_code) -{ -} + * hmm, not sure how to implement this cleanly yet, + * MacOS X represents this as one event, while [hid] represents it as two + * distinct axes. So the conversion requires an added hid_output_event(). + void hid_convert_hatswitch_values(IOHIDEventStruct event, t_symbol *type, t_atom *usage) + { + case 0: + name = gensym("abs_hat0y");value = 1; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = 0; + break; + case 1: + name = gensym("abs_hat0y");value = 1; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = 1; + break; + case 2: + name = gensym("abs_hat0y");value = 0; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = 1; + break; + case 3: + name = gensym("abs_hat0y");value = -1; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = 1; + break; + case 4: + name = gensym("abs_hat0y");value = -1; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = 0; + break; + case 5: + name = gensym("abs_hat0y");value = -1; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = -1; + break; + case 6: + name = gensym("abs_hat0y");value = 0; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = -1; + break; + case 7: + name = gensym("abs_hat0y");value = 1; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = -1; + break; + case 8: + name = gensym("abs_hat0y");value = 0; + hid_output_event(x, type, name, value); + name = gensym("abs_hat0x");value = 0; + break; + } + + } */ /* ============================================================================== */ /* DARWIN-SPECIFIC SUPPORT FUNCTIONS */ /* ============================================================================== */ -pRecDevice hid_get_device_by_number(t_int device_number) -{ - pRecDevice pCurrentHIDDevice; - t_int i, numdevs; - -// TODO: implement this using the global array built by hid_build_device_list() - -/* - * If the specified device is greater than the total number of devices, return - * an error. - */ - numdevs = (t_int) HIDCountDevices(); - if (device_number >= numdevs) { - error("[hid]: no such device, \"%d\", only %d devices found\n",device_number,numdevs); - return (NULL); - } -/* - * The most recently discovered HID is the first element of the list here. I - * want the oldest to be number 0 rather than the newest, so I use (numdevs - - * device_number - 1). - */ - pCurrentHIDDevice = HIDGetFirstDevice(); - for(i=0; i < numdevs - device_number - 1; ++i) - pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice); - - return pCurrentHIDDevice; -} - -t_int get_device_number_by_id(unsigned short vendor_id, unsigned short product_id) +short get_device_number_by_id(unsigned short vendor_id, unsigned short product_id) { debug_print(LOG_DEBUG,"get_device_number_from_usage_list"); pRecDevice pCurrentHIDDevice; t_int i; - t_int return_device_number = -1; + short return_device_number = -1; if( !HIDHaveDeviceList() ) hid_build_device_list(); @@ -240,14 +331,14 @@ t_int get_device_number_by_id(unsigned short vendor_id, unsigned short product_i return(return_device_number); } -t_int get_device_number_from_usage_list(t_int device_number, +short get_device_number_from_usage_list(short device_number, unsigned short usage_page, unsigned short usage) { - debug_print(LOG_DEBUG,"get_device_number_from_usage_list"); +// debug_print(LOG_DEBUG,"get_device_number_from_usage_list"); pRecDevice pCurrentHIDDevice; t_int i; - t_int return_device_number = -1; + short return_device_number = -1; t_int total_devices = 0; char cstrDeviceName[MAXPDSTRING]; @@ -291,97 +382,111 @@ t_int get_device_number_from_usage_list(t_int device_number, return(-1); } -/* + void hid_build_element_list(t_hid *x) { - if ( HIDIsValidDevice( device ) ) { - elRec = HIDGetFirstDeviceElement( js_devices[id].device, -kHIDElementTypeInput ); - if ( elRec ) { - switch (elRec->usagePage) { - case kHIDPage_GenericDesktop: - switch ( elRec->usage ) { - case kHIDUsage_GD_X: - x_axis = elRec; - break; - case kHIDUsage_GD_Y: - y_axis = elRec; - break; - case kHIDUsage_GD_GamePad: - pad = elRec; - break; - //etc - } - } - //if the right element was not found, continue looping through the - //rest of the elements by calling HIDGetNextDeviceElement() until you - //find the right one or it returns NULL - } - - // only queue buttons and relative axes - if ( HIDIsValidElement( devicePtr, elementPtr ) ) { - HIDQueueElement (devicePtr, elementPtr); - } - - // for absolute axes, poll them - if ( HIDIsValidElement( devicePtr, elementPtr ) ) { - value = HIDGetElementValue(devicePtr, elementPtr); - } + char type_name[256]; + char usage_name[256]; + pRecElement pCurrentHIDElement; + pRecDevice pCurrentHIDDevice = device_pointer[x->x_device_number]; + t_hid_element *new_element; + + element_count[x->x_device_number] = 0; + if( HIDIsValidDevice(pCurrentHIDDevice) ) + { + /* queuing one element at a time only works for the first element, so + * try queuing the whole device, then removing specific elements from + * the queue */ + HIDQueueDevice(pCurrentHIDDevice); + pCurrentHIDElement = HIDGetFirstDeviceElement( pCurrentHIDDevice, + kHIDElementTypeInput ); + while( pCurrentHIDElement != NULL) + { + /* these two functions just get the pretty names for display */ + HIDGetTypeName((IOHIDElementType) pCurrentHIDElement->type, type_name); + HIDGetUsageName(pCurrentHIDElement->usagePage, + pCurrentHIDElement->usage, usage_name); + + new_element = getbytes(sizeof(t_hid_element)); + new_element->os_pointer = (void *) pCurrentHIDElement; + get_usage_symbols(pCurrentHIDElement, new_element); + new_element->relative = pCurrentHIDElement->relative; + new_element->instance = get_type_name_instance(new_element->type, + new_element->name, + element_count[x->x_device_number], + element[x->x_device_number]); + + if( (pCurrentHIDElement->usagePage == kHIDPage_GenericDesktop) && + (!pCurrentHIDElement->relative) ) + { + switch(pCurrentHIDElement->usage) + { + case kHIDUsage_GD_X: + case kHIDUsage_GD_Y: + case kHIDUsage_GD_Z: + case kHIDUsage_GD_Rx: + case kHIDUsage_GD_Ry: + case kHIDUsage_GD_Rz: + case kHIDUsage_GD_Slider: + case kHIDUsage_GD_Dial: + case kHIDUsage_GD_Wheel: + //case kHIDUsage_GD_Hatswitch: // hatswitches are more like buttons, so queue them + debug_print(LOG_INFO,"[hid] storing absolute axis to poll %s, %s (0x%04x 0x%04x)", + type_name, usage_name, pCurrentHIDElement->usagePage, pCurrentHIDElement->usage); + if(HIDDequeueElement(pCurrentHIDDevice,pCurrentHIDElement) != kIOReturnSuccess) + debug_print(LOG_ERR,"[hid] could not dequeue element"); + new_element->polled = 1; + break; + default: + debug_print(LOG_CRIT,"[hid] SKIPPED %s, %s (0x%04x 0x%04x)x", type_name, usage_name, + pCurrentHIDElement->usagePage, pCurrentHIDElement->usage); + } + } + else + { + debug_print(LOG_INFO,"[hid] queuing element %s, %s (0x%04x 0x%04x)",type_name, usage_name, + pCurrentHIDElement->usagePage, pCurrentHIDElement->usage); + } + post("\tlogical min %d max %d",pCurrentHIDElement->minReport,pCurrentHIDElement->maxReport); + + element[x->x_device_number][element_count[x->x_device_number]] = new_element; + ++element_count[x->x_device_number]; + pCurrentHIDElement = HIDGetNextDeviceElement(pCurrentHIDElement, kHIDElementTypeInput); + } + } } -*/ -t_int hid_print_element_list(t_hid *x) +void hid_print_element_list(t_hid *x) { - debug_print(LOG_DEBUG,"hid_print_element_list"); - - UInt32 i; +// debug_print(LOG_DEBUG,"hid_print_element_list"); + int i; pRecElement pCurrentHIDElement; pRecDevice pCurrentHIDDevice; - UInt32 numElements; - char type[256]; - char code[256]; + t_hid_element *current_element; char type_name[256]; char usage_name[256]; -// pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number); pCurrentHIDDevice = device_pointer[x->x_device_number]; if ( ! HIDIsValidDevice(pCurrentHIDDevice) ) { error("[hid]: device %d is not a valid device\n",x->x_device_number); - return(1); + return; } - - pCurrentHIDElement = HIDGetFirstDeviceElement(pCurrentHIDDevice, kHIDElementTypeInput); - numElements = HIDCountDeviceElements(pCurrentHIDDevice, kHIDElementTypeInput); - - DEBUG(post("[hid] found %d elements:",numElements);); - - post(""); - post(" TYPE\tCODE\tEVENT NAME"); + post("[hid] found %d elements:",element_count[x->x_device_number]); + post("\n TYPE\tCODE\t#\tEVENT NAME"); post("-----------------------------------------------------------"); - for(i=0; ix_device_number]; i++) { + current_element = element[x->x_device_number][i]; + pCurrentHIDElement = (pRecElement) current_element->os_pointer; HIDGetTypeName((IOHIDElementType) pCurrentHIDElement->type, type_name); HIDGetUsageName(pCurrentHIDElement->usagePage, - pCurrentHIDElement->usage, usage_name); - - /* some events need more processing than others */ - switch(pCurrentHIDElement->usage) - { - case kHIDUsage_GD_Hatswitch: - post(" %s\t%s\t%s, %s","abs","abs_hat0x",type_name,usage_name); - post(" %s\t%s\t%s, %s","abs","abs_hat0y",type_name,usage_name); - break; - default: - convertDarwinElementToLinuxTypeCode(pCurrentHIDElement,type,code); - post(" %s\t%s\t%s, %s",type,code,type_name,usage_name); - } - - pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeInput); + pCurrentHIDElement->usage, usage_name); + post(" %s\t%s\t%d\t%s, %s", current_element->type->s_name, + current_element->name->s_name,(int) current_element->instance, + type_name, usage_name); } post(""); - - return (0); } @@ -394,15 +499,15 @@ void hid_ff_print( t_hid *x ) if ( x->x_has_ff ) { result = FFDeviceGetForceFeedbackProperty( (FFDeviceObjectReference) x->x_ff_device, - FFPROP_AUTOCENTER, - &value, - (IOByteCount) sizeof( value ) ); + FFPROP_AUTOCENTER, + &value, + (IOByteCount) sizeof( value ) ); if ( result == FF_OK ) post( "autocenter: %d",value ); result = FFDeviceGetForceFeedbackProperty( (FFDeviceObjectReference) x->x_ff_device, - FFPROP_FFGAIN, - &value, - (IOByteCount) sizeof( value ) ); + FFPROP_FFGAIN, + &value, + (IOByteCount) sizeof( value ) ); if ( result == FF_OK ) post( "gain: %d", value ); } @@ -412,9 +517,8 @@ void hid_ff_print( t_hid *x ) void hid_print_device_list(t_hid *x) { - char cstrDeviceName [256]; - t_int i,numdevs; -// UInt32 usagePage, usage; + char device_type_buffer[256]; + t_int i, numdevs; pRecDevice pCurrentHIDDevice = NULL; if( HIDHaveDeviceList() ) @@ -425,25 +529,18 @@ void hid_print_device_list(t_hid *x) /* display device list in console */ for(i=0; i < numdevs; i++) { -// pCurrentHIDDevice = hid_get_device_by_number(i); pCurrentHIDDevice = device_pointer[i]; - debug_print(LOG_INFO,"Device %d: '%s' '%s' version %d", - i, - pCurrentHIDDevice->manufacturer, - pCurrentHIDDevice->product, - pCurrentHIDDevice->version); - //usage - HIDGetUsageName(pCurrentHIDDevice->usagePage, - pCurrentHIDDevice->usage, - cstrDeviceName); - debug_print(LOG_INFO,"\t\tcstrDeviceName: %s",cstrDeviceName); - debug_print(LOG_INFO,"\t\tusage page: 0x%04x\tusage: 0x%04x", - pCurrentHIDDevice->usagePage, - pCurrentHIDDevice->usage); - debug_print(LOG_INFO,"\t\tvendorID: 0x%04x\tproductID: 0x%04x\tlocID: 0x%08x", - pCurrentHIDDevice->vendorID, - pCurrentHIDDevice->productID, - pCurrentHIDDevice->locID); + post("__________________________________________________"); + post("Device %d: '%s' '%s' version %d @ location 0x%08x", i, + pCurrentHIDDevice->manufacturer, pCurrentHIDDevice->product, + pCurrentHIDDevice->version,pCurrentHIDDevice->locID); + HIDGetUsageName(pCurrentHIDDevice->usagePage, pCurrentHIDDevice->usage, + device_type_buffer); + post("\tdevice type: %s\tusage page: 0x%04x\tusage: 0x%04x", + device_type_buffer, pCurrentHIDDevice->usagePage, + pCurrentHIDDevice->usage); + post("\tvendorID: 0x%04x\tproductID: 0x%04x", + pCurrentHIDDevice->vendorID, pCurrentHIDDevice->productID); } post(""); } @@ -491,13 +588,13 @@ void hid_platform_specific_info(t_hid *x) 1, output_atom); /* vendor id */ sprintf(vendor_id_string,"0x%04x", - (unsigned int)pCurrentHIDDevice->vendorID); + (unsigned int)pCurrentHIDDevice->vendorID); SETSYMBOL(output_atom, gensym(vendor_id_string)); outlet_anything( x->x_status_outlet, gensym("vendorID"), 1, output_atom); /* product id */ sprintf(product_id_string,"0x%04x", - (unsigned int)pCurrentHIDDevice->productID); + (unsigned int)pCurrentHIDDevice->productID); SETSYMBOL(output_atom, gensym(product_id_string)); outlet_anything( x->x_status_outlet, gensym("productID"), 1, output_atom); @@ -506,6 +603,175 @@ void hid_platform_specific_info(t_hid *x) freebytes(output_atom,sizeof(t_atom)); } +/* ============================================================================== */ +/* Pd [hid] FUNCTIONS */ +/* ============================================================================== */ + +void hid_get_events(t_hid *x) +{ + //debug_print(LOG_DEBUG,"hid_get_events"); + + unsigned int i; + pRecDevice pCurrentHIDDevice; + t_hid_element *current_element; + IOHIDEventStruct event; + + pCurrentHIDDevice = device_pointer[x->x_device_number]; + + /* get the queued events first and store them */ +// while( (HIDGetEvent(pCurrentHIDDevice, (void*) &event)) && (event_counter < MAX_EVENTS_PER_POLL) ) + while(HIDGetEvent(pCurrentHIDDevice, (void*) &event)) + { + i=0; + do { + current_element = element[x->x_device_number][i]; + ++i; + } while( (i < element_count[x->x_device_number]) && + (((pRecElement)current_element->os_pointer)->cookie != + (IOHIDElementCookie) event.elementCookie) ); + + current_element->value = event.value; + debug_print(LOG_DEBUG,"output this: %s %s %d prev %d",current_element->type->s_name, + current_element->name->s_name, current_element->value, + current_element->previous_value); + } + /* absolute axes don't need to be queued, they can just be polled */ + for(i=0; i< element_count[x->x_device_number]; ++i) + { + current_element = element[x->x_device_number][i]; + if(current_element->polled) + { + current_element->value = + HIDGetElementValue(pCurrentHIDDevice, + (pRecElement)current_element->os_pointer); + } + if(current_element->previous_value != current_element->value) + { + hid_output_event(x, current_element); + if(!current_element->relative) + current_element->previous_value = current_element->value; + } + } +} + + +t_int hid_open_device(t_hid *x, short device_number) +{ + debug_print(LOG_DEBUG,"hid_open_device"); + + t_int result = 0; + pRecDevice pCurrentHIDDevice = NULL; + + io_service_t hidDevice = 0; + FFDeviceObjectReference ffDeviceReference = NULL; + +/* rebuild device list to make sure the list is current */ + if( !HIDHaveDeviceList() ) hid_build_device_list(); + +// pCurrentHIDDevice = hid_get_device_by_number(device_number); + pCurrentHIDDevice = device_pointer[device_number]; + if( HIDIsValidDevice(pCurrentHIDDevice) ) + { + x->x_device_number = device_number; + } + else + { + debug_error(x,LOG_ERR,"[hid]: device %d is not a valid device\n",device_number); + return(1); + } + debug_print(LOG_WARNING,"[hid] opened device %d: %s %s", + device_number, pCurrentHIDDevice->manufacturer, pCurrentHIDDevice->product); + + hid_build_element_list(x); + + hidDevice = AllocateHIDObjectFromRecDevice( pCurrentHIDDevice ); + if( FFIsForceFeedback(hidDevice) == FF_OK ) + { + debug_print(LOG_WARNING,"\tdevice has Force Feedback support"); + if( FFCreateDevice(hidDevice,&ffDeviceReference) == FF_OK ) + { + x->x_has_ff = 1; + x->x_ff_device = ffDeviceReference; + } + else + { + x->x_has_ff = 0; + post("[hid]: FF device creation failed!"); + return( -1 ); + } + } + return(result); +} + + +t_int hid_close_device(t_hid *x) +{ + debug_print(LOG_DEBUG,"hid_close_device"); + + t_int result = 0; +// pRecDevice pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number); + pRecDevice pCurrentHIDDevice = device_pointer[x->x_device_number]; + + HIDDequeueDevice(pCurrentHIDDevice); +// this doesn't seem to be needed at all, but why not use it? +// result = HIDCloseReleaseInterface(pCurrentHIDDevice); + + return(result); +} + + +void hid_build_device_list(void) +{ + int device_number = 0; + pRecDevice pCurrentHIDDevice; + + debug_print(LOG_DEBUG,"hid_build_device_list"); + + debug_print(LOG_WARNING,"[hid] Building device list..."); + if(HIDBuildDeviceList (0, 0)) + post("[hid]: no HID devices found\n"); + +/* The most recently discovered HID is the first element of the list here. I + * want the oldest to be number 0 rather than the newest. */ + device_number = (int) HIDCountDevices(); + pCurrentHIDDevice = HIDGetFirstDevice(); + while(pCurrentHIDDevice != NULL) + { + --device_number; + if(device_number < MAX_DEVICES) + device_pointer[device_number] = pCurrentHIDDevice; + pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice); + } + + debug_print(LOG_WARNING,"[hid] completed device list."); +} + + +void hid_print(t_hid *x) +{ + if( !HIDHaveDeviceList() ) hid_build_device_list(); + hid_print_device_list(x); + if(x->x_device_open) + { + hid_print_element_list(x); + hid_ff_print(x); + } +} + + +void hid_platform_specific_free(t_hid *x) +{ + debug_print(LOG_DEBUG,"hid_platform_specific_free"); +/* only call this if the last instance is being freed */ + if (hid_instance_count < 1) + { + DEBUG(post("RELEASE ALL hid_instance_count: %d", hid_instance_count);); + HIDReleaseAllDeviceQueues(); + HIDReleaseDeviceList(); + } +} + + /* ============================================================================== * FORCE FEEDBACK * ============================================================================== */ @@ -634,290 +900,14 @@ t_int hid_ff_motors( t_hid *x, t_float value ) t_int hid_ff_fftest ( t_hid *x, t_float value) { - debug_print(LOG_DEBUG,"hid_get_events"); + debug_print(LOG_DEBUG,"hid_ff_fftest"); return( 0 ); } -/* ============================================================================== */ -/* Pd [hid] FUNCTIONS */ -/* ============================================================================== */ - -t_int hid_get_events(t_hid *x) -{ - //debug_print(LOG_DEBUG,"hid_get_events"); - - SInt32 value; - pRecDevice pCurrentHIDDevice; - pRecElement pCurrentHIDElement; - IOHIDEventStruct event; - char type[256]; - char code[256]; - char event_output_string[256]; -// t_atom event_data[4]; - - int event_counter = 0; -// Boolean result; - -// pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number); - pCurrentHIDDevice = device_pointer[x->x_device_number]; - - if(!pCurrentHIDDevice) - { - post("[hid] can't find current device %d. Was it unplugged?",x->x_device_number); - return (1); - } - - while( (HIDGetEvent(pCurrentHIDDevice, (void*) &event)) && (event_counter < 64) ) - { - value = event.value; - //post("found event: %d",value); - IOHIDElementCookie cookie = (IOHIDElementCookie) event.elementCookie; - - // find the pRecElement using the cookie - pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeIO); - while (pCurrentHIDElement && (pCurrentHIDElement->cookie != cookie)) - pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeIO); - - DEBUG( - HIDGetElementNameFromVendorProductCookie( - pCurrentHIDDevice->vendorID, pCurrentHIDDevice->productID, - (long) pCurrentHIDElement->cookie, event_output_string); - ); //end DEBUG - - /* some events need more processing than others */ - switch(pCurrentHIDElement->usage) - { - case kHIDUsage_GD_Hatswitch: - sprintf(type,"abs"); - switch (value) - { -/* - * MacOS X represents this as one event, while [hid] represents it as two - * distinct axes. So the conversion requires an added hid_output_event(). +/* ---------------------------------------------------------------------------------------------------- + * the big monster look up table (not used yet) */ - case 0: - sprintf(code,"abs_hat0y");value = 1; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = 0; - break; - case 1: - sprintf(code,"abs_hat0y");value = 1; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = 1; - break; - case 2: - sprintf(code,"abs_hat0y");value = 0; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = 1; - break; - case 3: - sprintf(code,"abs_hat0y");value = -1; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = 1; - break; - case 4: - sprintf(code,"abs_hat0y");value = -1; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = 0; - break; - case 5: - sprintf(code,"abs_hat0y");value = -1; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = -1; - break; - case 6: - sprintf(code,"abs_hat0y");value = 0; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = -1; - break; - case 7: - sprintf(code,"abs_hat0y");value = 1; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = -1; - break; - case 8: - sprintf(code,"abs_hat0y");value = 0; - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - sprintf(code,"abs_hat0x");value = 0; - break; - } - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - break; - default: - convertDarwinElementToLinuxTypeCode(pCurrentHIDElement,type,code); - hid_output_event(x,gensym(type),gensym(code),(t_float)value); - } - -// DEBUG(post("type: %s code: %s event name: %s",type,code,event_output_string);); - - - ++event_counter; - } - DEBUG( -// if(event_counter) -// post("output %d events",event_counter); - ); -/* /\* get the first element *\/ */ -/* pCurrentHIDElement = HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeIO); */ -/* /\* cycle thru all elements *\/ */ -/* while (pCurrentHIDElement) */ -/* { */ -/* //value = HIDGetElementValue (pCurrentHIDDevice, pCurrentHIDElement); */ - -/* if (pCurrentHIDElement) */ -/* { */ -/* value = HIDGetElementValue (pCurrentHIDDevice, pCurrentHIDElement); */ -/* post("current value: %d", value); */ -/* // if it's not a button and it's not a hatswitch then calibrate */ -/* /\* if(( pCurrentHIDElement->type != kIOHIDElementTypeInput_Button ) && *\/ */ -/* /\* ( pCurrentHIDElement->usagePage == 0x01 && pCurrentHIDElement->usage != kHIDUsage_GD_Hatswitch)) *\/ */ -/* /\* value = HIDCalibrateValue ( value, pCurrentHIDElement ); *\/ */ - -/* /\* type *\/ */ -/* //HIDGetTypeName(pCurrentHIDElement->type,type); */ -/* convertDarwinToLinuxType((IOHIDElementType) pCurrentHIDElement->type, event_output_string); */ -/* SETSYMBOL(event_data, gensym(event_output_string)); */ -/* /\* code *\/ */ -/* HIDGetUsageName(pCurrentHIDElement->usagePage, pCurrentHIDElement->usage, event_output_string); */ -/* SETSYMBOL(event_data + 1, gensym(event_output_string)); */ -/* /\* value *\/ */ -/* SETFLOAT(event_data + 2, (t_float)value); */ -/* /\* time *\/ */ -/* // TODO temp space filler for testing, got to find where I get the event time */ -/* SETFLOAT(event_data + 3, (t_float)value); */ -/* // SETFLOAT(event_data + 3, (t_float)(hid_input_event.time).tv_sec); */ -/* outlet_anything(x->x_obj.te_outlet,atom_gensym(event_data),3,event_data+1); */ -/* } */ -/* pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeIO); */ -/* } */ - return (0); -} - - -t_int hid_open_device(t_hid *x, t_int device_number) -{ - debug_print(LOG_DEBUG,"hid_open_device"); - - t_int result = 0; - pRecDevice pCurrentHIDDevice = NULL; - - io_service_t hidDevice = 0; - FFDeviceObjectReference ffDeviceReference = NULL; - -/* rebuild device list to make sure the list is current */ - if( !HIDHaveDeviceList() ) hid_build_device_list(); - -// pCurrentHIDDevice = hid_get_device_by_number(device_number); - pCurrentHIDDevice = device_pointer[device_number]; - if( HIDIsValidDevice(pCurrentHIDDevice) ) - { - x->x_device_number = device_number; - } - else - { - debug_error(x,LOG_ERR,"[hid]: device %d is not a valid device\n",device_number); - return(1); - } - debug_print(LOG_WARNING,"[hid] opened device %d: %s %s", - device_number, pCurrentHIDDevice->manufacturer, pCurrentHIDDevice->product); - - //hid_build_element_list(x); - - hidDevice = AllocateHIDObjectFromRecDevice( pCurrentHIDDevice ); - if( FFIsForceFeedback(hidDevice) == FF_OK ) - { - debug_print(LOG_WARNING,"\tdevice has Force Feedback support"); - if( FFCreateDevice(hidDevice,&ffDeviceReference) == FF_OK ) - { - x->x_has_ff = 1; - x->x_ff_device = ffDeviceReference; - } - else - { - x->x_has_ff = 0; - post("[hid]: FF device creation failed!"); - return( -1 ); - } - } - - - HIDQueueDevice(pCurrentHIDDevice); -// TODO: queue all elements except absolute axes, those can just be polled -/* if ( HIDIsValidElement( devicePtr, elementPtr ) ) { - value = HIDGetElementValue(devicePtr, elementPtr); - } -*/ - return(result); -} - - -t_int hid_close_device(t_hid *x) -{ - debug_print(LOG_DEBUG,"hid_close_device"); - - t_int result = 0; -// pRecDevice pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number); - pRecDevice pCurrentHIDDevice = device_pointer[x->x_device_number]; - - HIDDequeueDevice(pCurrentHIDDevice); -// this doesn't seem to be needed at all, but why not use it? -// result = HIDCloseReleaseInterface(pCurrentHIDDevice); - - return(result); -} - - -void hid_build_device_list(void) -{ - int device_number = 0; - pRecDevice pCurrentHIDDevice; - - debug_print(LOG_DEBUG,"hid_build_device_list"); - - debug_print(LOG_WARNING,"[hid] Building device list..."); - if(HIDBuildDeviceList (0, 0)) - post("[hid]: no HID devices found\n"); - -/* The most recently discovered HID is the first element of the list here. I - * want the oldest to be number 0 rather than the newest. */ - device_number = (int) HIDCountDevices(); - pCurrentHIDDevice = HIDGetFirstDevice(); - while(pCurrentHIDDevice != NULL) - { - --device_number; - if(device_number < MAX_DEVICES) - device_pointer[device_number] = pCurrentHIDDevice; - pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice); - } - - debug_print(LOG_WARNING,"[hid] completed device list."); -} - - -void hid_print(t_hid *x) -{ - hid_print_device_list(x); - - if(x->x_device_open) - { - hid_print_element_list(x); - hid_ff_print( x ); - } -} - - -void hid_platform_specific_free(t_hid *x) -{ - debug_print(LOG_DEBUG,"hid_platform_specific_free"); -/* only call this if the last instance is being freed */ - if (hid_instance_count < 1) - { - DEBUG(post("RELEASE ALL hid_instance_count: %d", hid_instance_count);); - HIDReleaseAllDeviceQueues(); - HIDReleaseDeviceList(); - } -} //void HIDGetUsageName (const long valueUsagePage, const long valueUsage, char * cstrName) char *convertEventsFromDarwinToLinux(pRecElement element) @@ -929,541 +919,542 @@ char *convertEventsFromDarwinToLinux(pRecElement element) switch (element->usagePage) { - case kHIDPage_Undefined: + case kHIDPage_Undefined: + switch (element->usage) + { + default: sprintf (cstrName, "Undefined Page, Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_GenericDesktop: + switch (element->usage) + { + case kHIDUsage_GD_Pointer: sprintf (cstrName, "Pointer"); break; + case kHIDUsage_GD_Mouse: sprintf (cstrName, "Mouse"); break; + case kHIDUsage_GD_Joystick: sprintf (cstrName, "Joystick"); break; + case kHIDUsage_GD_GamePad: sprintf (cstrName, "GamePad"); break; + case kHIDUsage_GD_Keyboard: sprintf (cstrName, "Keyboard"); break; + case kHIDUsage_GD_Keypad: sprintf (cstrName, "Keypad"); break; + case kHIDUsage_GD_MultiAxisController: sprintf (cstrName, "Multi-Axis Controller"); break; + + case kHIDUsage_GD_X: sprintf (cstrName, "X-Axis"); break; + case kHIDUsage_GD_Y: sprintf (cstrName, "Y-Axis"); break; + case kHIDUsage_GD_Z: sprintf (cstrName, "Z-Axis"); break; + case kHIDUsage_GD_Rx: sprintf (cstrName, "X-Rotation"); break; + case kHIDUsage_GD_Ry: sprintf (cstrName, "Y-Rotation"); break; + case kHIDUsage_GD_Rz: sprintf (cstrName, "Z-Rotation"); break; + case kHIDUsage_GD_Slider: sprintf (cstrName, "Slider"); break; + case kHIDUsage_GD_Dial: sprintf (cstrName, "Dial"); break; + case kHIDUsage_GD_Wheel: sprintf (cstrName, "Wheel"); break; + case kHIDUsage_GD_Hatswitch: sprintf (cstrName, "Hatswitch"); break; + case kHIDUsage_GD_CountedBuffer: sprintf (cstrName, "Counted Buffer"); break; + case kHIDUsage_GD_ByteCount: sprintf (cstrName, "Byte Count"); break; + case kHIDUsage_GD_MotionWakeup: sprintf (cstrName, "Motion Wakeup"); break; + case kHIDUsage_GD_Start: sprintf (cstrName, "Start"); break; + case kHIDUsage_GD_Select: sprintf (cstrName, "Select"); break; + + case kHIDUsage_GD_Vx: sprintf (cstrName, "X-Velocity"); break; + case kHIDUsage_GD_Vy: sprintf (cstrName, "Y-Velocity"); break; + case kHIDUsage_GD_Vz: sprintf (cstrName, "Z-Velocity"); break; + case kHIDUsage_GD_Vbrx: sprintf (cstrName, "X-Rotation Velocity"); break; + case kHIDUsage_GD_Vbry: sprintf (cstrName, "Y-Rotation Velocity"); break; + case kHIDUsage_GD_Vbrz: sprintf (cstrName, "Z-Rotation Velocity"); break; + case kHIDUsage_GD_Vno: sprintf (cstrName, "Vno"); break; + + case kHIDUsage_GD_SystemControl: sprintf (cstrName, "System Control"); break; + case kHIDUsage_GD_SystemPowerDown: sprintf (cstrName, "System Power Down"); break; + case kHIDUsage_GD_SystemSleep: sprintf (cstrName, "System Sleep"); break; + case kHIDUsage_GD_SystemWakeUp: sprintf (cstrName, "System Wake Up"); break; + case kHIDUsage_GD_SystemContextMenu: sprintf (cstrName, "System Context Menu"); break; + case kHIDUsage_GD_SystemMainMenu: sprintf (cstrName, "System Main Menu"); break; + case kHIDUsage_GD_SystemAppMenu: sprintf (cstrName, "System App Menu"); break; + case kHIDUsage_GD_SystemMenuHelp: sprintf (cstrName, "System Menu Help"); break; + case kHIDUsage_GD_SystemMenuExit: sprintf (cstrName, "System Menu Exit"); break; + case kHIDUsage_GD_SystemMenu: sprintf (cstrName, "System Menu"); break; + case kHIDUsage_GD_SystemMenuRight: sprintf (cstrName, "System Menu Right"); break; + case kHIDUsage_GD_SystemMenuLeft: sprintf (cstrName, "System Menu Left"); break; + case kHIDUsage_GD_SystemMenuUp: sprintf (cstrName, "System Menu Up"); break; + case kHIDUsage_GD_SystemMenuDown: sprintf (cstrName, "System Menu Down"); break; + + case kHIDUsage_GD_DPadUp: sprintf (cstrName, "DPad Up"); break; + case kHIDUsage_GD_DPadDown: sprintf (cstrName, "DPad Down"); break; + case kHIDUsage_GD_DPadRight: sprintf (cstrName, "DPad Right"); break; + case kHIDUsage_GD_DPadLeft: sprintf (cstrName, "DPad Left"); break; + + case kHIDUsage_GD_Reserved: sprintf (cstrName, "Reserved"); break; + + default: sprintf (cstrName, "Generic Desktop Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Simulation: + switch (element->usage) + { + default: sprintf (cstrName, "Simulation Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_VR: + switch (element->usage) + { + default: sprintf (cstrName, "VR Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Sport: + switch (element->usage) + { + default: sprintf (cstrName, "Sport Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Game: + switch (element->usage) + { + default: sprintf (cstrName, "Game Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_KeyboardOrKeypad: + switch (element->usage) + { + default: sprintf (cstrName, "Keyboard Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_LEDs: + switch (element->usage) + { + // some LED usages + case kHIDUsage_LED_IndicatorRed: sprintf (cstrName, "Red LED"); break; + case kHIDUsage_LED_IndicatorGreen: sprintf (cstrName, "Green LED"); break; + case kHIDUsage_LED_IndicatorAmber: sprintf (cstrName, "Amber LED"); break; + case kHIDUsage_LED_GenericIndicator: sprintf (cstrName, "Generic LED"); break; + case kHIDUsage_LED_SystemSuspend: sprintf (cstrName, "System Suspend LED"); break; + case kHIDUsage_LED_ExternalPowerConnected: sprintf (cstrName, "External Power LED"); break; + default: sprintf (cstrName, "LED Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Button: + switch (element->usage) + { + default: sprintf (cstrName, "Button #%ld", element->usage); break; + } + break; + case kHIDPage_Ordinal: + switch (element->usage) + { + default: sprintf (cstrName, "Ordinal Instance %lx", element->usage); break; + } + break; + case kHIDPage_Telephony: + switch (element->usage) + { + default: sprintf (cstrName, "Telephony Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Consumer: + switch (element->usage) + { + default: sprintf (cstrName, "Consumer Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Digitizer: + switch (element->usage) + { + default: sprintf (cstrName, "Digitizer Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_PID: + if (((element->usage >= 0x02) && (element->usage <= 0x1F)) || ((element->usage >= 0x29) && (element->usage <= 0x2F)) || + ((element->usage >= 0x35) && (element->usage <= 0x3F)) || ((element->usage >= 0x44) && (element->usage <= 0x4F)) || + (element->usage == 0x8A) || (element->usage == 0x93) || ((element->usage >= 0x9D) && (element->usage <= 0x9E)) || + ((element->usage >= 0xA1) && (element->usage <= 0xA3)) || ((element->usage >= 0xAD) && (element->usage <= 0xFFFF))) + sprintf (cstrName, "PID Reserved"); + else switch (element->usage) - { - default: sprintf (cstrName, "Undefined Page, Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_GenericDesktop: - switch (element->usage) - { - case kHIDUsage_GD_Pointer: sprintf (cstrName, "Pointer"); break; - case kHIDUsage_GD_Mouse: sprintf (cstrName, "Mouse"); break; - case kHIDUsage_GD_Joystick: sprintf (cstrName, "Joystick"); break; - case kHIDUsage_GD_GamePad: sprintf (cstrName, "GamePad"); break; - case kHIDUsage_GD_Keyboard: sprintf (cstrName, "Keyboard"); break; - case kHIDUsage_GD_Keypad: sprintf (cstrName, "Keypad"); break; - case kHIDUsage_GD_MultiAxisController: sprintf (cstrName, "Multi-Axis Controller"); break; - - case kHIDUsage_GD_X: sprintf (cstrName, "X-Axis"); break; - case kHIDUsage_GD_Y: sprintf (cstrName, "Y-Axis"); break; - case kHIDUsage_GD_Z: sprintf (cstrName, "Z-Axis"); break; - case kHIDUsage_GD_Rx: sprintf (cstrName, "X-Rotation"); break; - case kHIDUsage_GD_Ry: sprintf (cstrName, "Y-Rotation"); break; - case kHIDUsage_GD_Rz: sprintf (cstrName, "Z-Rotation"); break; - case kHIDUsage_GD_Slider: sprintf (cstrName, "Slider"); break; - case kHIDUsage_GD_Dial: sprintf (cstrName, "Dial"); break; - case kHIDUsage_GD_Wheel: sprintf (cstrName, "Wheel"); break; - case kHIDUsage_GD_Hatswitch: sprintf (cstrName, "Hatswitch"); break; - case kHIDUsage_GD_CountedBuffer: sprintf (cstrName, "Counted Buffer"); break; - case kHIDUsage_GD_ByteCount: sprintf (cstrName, "Byte Count"); break; - case kHIDUsage_GD_MotionWakeup: sprintf (cstrName, "Motion Wakeup"); break; - case kHIDUsage_GD_Start: sprintf (cstrName, "Start"); break; - case kHIDUsage_GD_Select: sprintf (cstrName, "Select"); break; - - case kHIDUsage_GD_Vx: sprintf (cstrName, "X-Velocity"); break; - case kHIDUsage_GD_Vy: sprintf (cstrName, "Y-Velocity"); break; - case kHIDUsage_GD_Vz: sprintf (cstrName, "Z-Velocity"); break; - case kHIDUsage_GD_Vbrx: sprintf (cstrName, "X-Rotation Velocity"); break; - case kHIDUsage_GD_Vbry: sprintf (cstrName, "Y-Rotation Velocity"); break; - case kHIDUsage_GD_Vbrz: sprintf (cstrName, "Z-Rotation Velocity"); break; - case kHIDUsage_GD_Vno: sprintf (cstrName, "Vno"); break; - - case kHIDUsage_GD_SystemControl: sprintf (cstrName, "System Control"); break; - case kHIDUsage_GD_SystemPowerDown: sprintf (cstrName, "System Power Down"); break; - case kHIDUsage_GD_SystemSleep: sprintf (cstrName, "System Sleep"); break; - case kHIDUsage_GD_SystemWakeUp: sprintf (cstrName, "System Wake Up"); break; - case kHIDUsage_GD_SystemContextMenu: sprintf (cstrName, "System Context Menu"); break; - case kHIDUsage_GD_SystemMainMenu: sprintf (cstrName, "System Main Menu"); break; - case kHIDUsage_GD_SystemAppMenu: sprintf (cstrName, "System App Menu"); break; - case kHIDUsage_GD_SystemMenuHelp: sprintf (cstrName, "System Menu Help"); break; - case kHIDUsage_GD_SystemMenuExit: sprintf (cstrName, "System Menu Exit"); break; - case kHIDUsage_GD_SystemMenu: sprintf (cstrName, "System Menu"); break; - case kHIDUsage_GD_SystemMenuRight: sprintf (cstrName, "System Menu Right"); break; - case kHIDUsage_GD_SystemMenuLeft: sprintf (cstrName, "System Menu Left"); break; - case kHIDUsage_GD_SystemMenuUp: sprintf (cstrName, "System Menu Up"); break; - case kHIDUsage_GD_SystemMenuDown: sprintf (cstrName, "System Menu Down"); break; - - case kHIDUsage_GD_DPadUp: sprintf (cstrName, "DPad Up"); break; - case kHIDUsage_GD_DPadDown: sprintf (cstrName, "DPad Down"); break; - case kHIDUsage_GD_DPadRight: sprintf (cstrName, "DPad Right"); break; - case kHIDUsage_GD_DPadLeft: sprintf (cstrName, "DPad Left"); break; - - case kHIDUsage_GD_Reserved: sprintf (cstrName, "Reserved"); break; - - default: sprintf (cstrName, "Generic Desktop Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Simulation: - switch (element->usage) - { - default: sprintf (cstrName, "Simulation Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_VR: - switch (element->usage) - { - default: sprintf (cstrName, "VR Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Sport: - switch (element->usage) - { - default: sprintf (cstrName, "Sport Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Game: - switch (element->usage) - { - default: sprintf (cstrName, "Game Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_KeyboardOrKeypad: - switch (element->usage) - { - default: sprintf (cstrName, "Keyboard Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_LEDs: - switch (element->usage) - { - // some LED usages - case kHIDUsage_LED_IndicatorRed: sprintf (cstrName, "Red LED"); break; - case kHIDUsage_LED_IndicatorGreen: sprintf (cstrName, "Green LED"); break; - case kHIDUsage_LED_IndicatorAmber: sprintf (cstrName, "Amber LED"); break; - case kHIDUsage_LED_GenericIndicator: sprintf (cstrName, "Generic LED"); break; - case kHIDUsage_LED_SystemSuspend: sprintf (cstrName, "System Suspend LED"); break; - case kHIDUsage_LED_ExternalPowerConnected: sprintf (cstrName, "External Power LED"); break; - default: sprintf (cstrName, "LED Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Button: - switch (element->usage) - { - default: sprintf (cstrName, "Button #%ld", element->usage); break; - } - break; - case kHIDPage_Ordinal: - switch (element->usage) - { - default: sprintf (cstrName, "Ordinal Instance %lx", element->usage); break; - } - break; - case kHIDPage_Telephony: - switch (element->usage) - { - default: sprintf (cstrName, "Telephony Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Consumer: - switch (element->usage) - { - default: sprintf (cstrName, "Consumer Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Digitizer: - switch (element->usage) - { - default: sprintf (cstrName, "Digitizer Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_PID: - if (((element->usage >= 0x02) && (element->usage <= 0x1F)) || ((element->usage >= 0x29) && (element->usage <= 0x2F)) || - ((element->usage >= 0x35) && (element->usage <= 0x3F)) || ((element->usage >= 0x44) && (element->usage <= 0x4F)) || - (element->usage == 0x8A) || (element->usage == 0x93) || ((element->usage >= 0x9D) && (element->usage <= 0x9E)) || - ((element->usage >= 0xA1) && (element->usage <= 0xA3)) || ((element->usage >= 0xAD) && (element->usage <= 0xFFFF))) - sprintf (cstrName, "PID Reserved"); - else - switch (element->usage) - { - case 0x00: sprintf (cstrName, "PID Undefined Usage"); break; - case kHIDUsage_PID_PhysicalInterfaceDevice: sprintf (cstrName, "Physical Interface Device"); break; - case kHIDUsage_PID_Normal: sprintf (cstrName, "Normal Force"); break; - - case kHIDUsage_PID_SetEffectReport: sprintf (cstrName, "Set Effect Report"); break; - case kHIDUsage_PID_EffectBlockIndex: sprintf (cstrName, "Effect Block Index"); break; - case kHIDUsage_PID_ParamBlockOffset: sprintf (cstrName, "Parameter Block Offset"); break; - case kHIDUsage_PID_ROM_Flag: sprintf (cstrName, "ROM Flag"); break; - - case kHIDUsage_PID_EffectType: sprintf (cstrName, "Effect Type"); break; - case kHIDUsage_PID_ET_ConstantForce: sprintf (cstrName, "Effect Type Constant Force"); break; - case kHIDUsage_PID_ET_Ramp: sprintf (cstrName, "Effect Type Ramp"); break; - case kHIDUsage_PID_ET_CustomForceData: sprintf (cstrName, "Effect Type Custom Force Data"); break; - case kHIDUsage_PID_ET_Square: sprintf (cstrName, "Effect Type Square"); break; - case kHIDUsage_PID_ET_Sine: sprintf (cstrName, "Effect Type Sine"); break; - case kHIDUsage_PID_ET_Triangle: sprintf (cstrName, "Effect Type Triangle"); break; - case kHIDUsage_PID_ET_SawtoothUp: sprintf (cstrName, "Effect Type Sawtooth Up"); break; - case kHIDUsage_PID_ET_SawtoothDown: sprintf (cstrName, "Effect Type Sawtooth Down"); break; - case kHIDUsage_PID_ET_Spring: sprintf (cstrName, "Effect Type Spring"); break; - case kHIDUsage_PID_ET_Damper: sprintf (cstrName, "Effect Type Damper"); break; - case kHIDUsage_PID_ET_Inertia: sprintf (cstrName, "Effect Type Inertia"); break; - case kHIDUsage_PID_ET_Friction: sprintf (cstrName, "Effect Type Friction"); break; - case kHIDUsage_PID_Duration: sprintf (cstrName, "Effect Duration"); break; - case kHIDUsage_PID_SamplePeriod: sprintf (cstrName, "Effect Sample Period"); break; - case kHIDUsage_PID_Gain: sprintf (cstrName, "Effect Gain"); break; - case kHIDUsage_PID_TriggerButton: sprintf (cstrName, "Effect Trigger Button"); break; - case kHIDUsage_PID_TriggerRepeatInterval: sprintf (cstrName, "Effect Trigger Repeat Interval"); break; - - case kHIDUsage_PID_AxesEnable: sprintf (cstrName, "Axis Enable"); break; - case kHIDUsage_PID_DirectionEnable: sprintf (cstrName, "Direction Enable"); break; - - case kHIDUsage_PID_Direction: sprintf (cstrName, "Direction"); break; - - case kHIDUsage_PID_TypeSpecificBlockOffset: sprintf (cstrName, "Type Specific Block Offset"); break; - - case kHIDUsage_PID_BlockType: sprintf (cstrName, "Block Type"); break; - - case kHIDUsage_PID_SetEnvelopeReport: sprintf (cstrName, "Set Envelope Report"); break; - case kHIDUsage_PID_AttackLevel: sprintf (cstrName, "Envelope Attack Level"); break; - case kHIDUsage_PID_AttackTime: sprintf (cstrName, "Envelope Attack Time"); break; - case kHIDUsage_PID_FadeLevel: sprintf (cstrName, "Envelope Fade Level"); break; - case kHIDUsage_PID_FadeTime: sprintf (cstrName, "Envelope Fade Time"); break; - - case kHIDUsage_PID_SetConditionReport: sprintf (cstrName, "Set Condition Report"); break; - case kHIDUsage_PID_CP_Offset: sprintf (cstrName, "Condition CP Offset"); break; - case kHIDUsage_PID_PositiveCoefficient: sprintf (cstrName, "Condition Positive Coefficient"); break; - case kHIDUsage_PID_NegativeCoefficient: sprintf (cstrName, "Condition Negative Coefficient"); break; - case kHIDUsage_PID_PositiveSaturation: sprintf (cstrName, "Condition Positive Saturation"); break; - case kHIDUsage_PID_NegativeSaturation: sprintf (cstrName, "Condition Negative Saturation"); break; - case kHIDUsage_PID_DeadBand: sprintf (cstrName, "Condition Dead Band"); break; - - case kHIDUsage_PID_DownloadForceSample: sprintf (cstrName, "Download Force Sample"); break; - case kHIDUsage_PID_IsochCustomForceEnable: sprintf (cstrName, "Isoch Custom Force Enable"); break; - - case kHIDUsage_PID_CustomForceDataReport: sprintf (cstrName, "Custom Force Data Report"); break; - case kHIDUsage_PID_CustomForceData: sprintf (cstrName, "Custom Force Data"); break; - - case kHIDUsage_PID_CustomForceVendorDefinedData: sprintf (cstrName, "Custom Force Vendor Defined Data"); break; - case kHIDUsage_PID_SetCustomForceReport: sprintf (cstrName, "Set Custom Force Report"); break; - case kHIDUsage_PID_CustomForceDataOffset: sprintf (cstrName, "Custom Force Data Offset"); break; - case kHIDUsage_PID_SampleCount: sprintf (cstrName, "Custom Force Sample Count"); break; - - case kHIDUsage_PID_SetPeriodicReport: sprintf (cstrName, "Set Periodic Report"); break; - case kHIDUsage_PID_Offset: sprintf (cstrName, "Periodic Offset"); break; - case kHIDUsage_PID_Magnitude: sprintf (cstrName, "Periodic Magnitude"); break; - case kHIDUsage_PID_Phase: sprintf (cstrName, "Periodic Phase"); break; - case kHIDUsage_PID_Period: sprintf (cstrName, "Periodic Period"); break; - - case kHIDUsage_PID_SetConstantForceReport: sprintf (cstrName, "Set Constant Force Report"); break; - - case kHIDUsage_PID_SetRampForceReport: sprintf (cstrName, "Set Ramp Force Report"); break; - case kHIDUsage_PID_RampStart: sprintf (cstrName, "Ramp Start"); break; - case kHIDUsage_PID_RampEnd: sprintf (cstrName, "Ramp End"); break; - - case kHIDUsage_PID_EffectOperationReport: sprintf (cstrName, "Effect Operation Report"); break; - - case kHIDUsage_PID_EffectOperation: sprintf (cstrName, "Effect Operation"); break; - case kHIDUsage_PID_OpEffectStart: sprintf (cstrName, "Op Effect Start"); break; - case kHIDUsage_PID_OpEffectStartSolo: sprintf (cstrName, "Op Effect Start Solo"); break; - case kHIDUsage_PID_OpEffectStop: sprintf (cstrName, "Op Effect Stop"); break; - case kHIDUsage_PID_LoopCount: sprintf (cstrName, "Op Effect Loop Count"); break; - - case kHIDUsage_PID_DeviceGainReport: sprintf (cstrName, "Device Gain Report"); break; - case kHIDUsage_PID_DeviceGain: sprintf (cstrName, "Device Gain"); break; - - case kHIDUsage_PID_PoolReport: sprintf (cstrName, "PID Pool Report"); break; - case kHIDUsage_PID_RAM_PoolSize: sprintf (cstrName, "RAM Pool Size"); break; - case kHIDUsage_PID_ROM_PoolSize: sprintf (cstrName, "ROM Pool Size"); break; - case kHIDUsage_PID_ROM_EffectBlockCount: sprintf (cstrName, "ROM Effect Block Count"); break; - case kHIDUsage_PID_SimultaneousEffectsMax: sprintf (cstrName, "Simultaneous Effects Max"); break; - case kHIDUsage_PID_PoolAlignment: sprintf (cstrName, "Pool Alignment"); break; - - case kHIDUsage_PID_PoolMoveReport: sprintf (cstrName, "PID Pool Move Report"); break; - case kHIDUsage_PID_MoveSource: sprintf (cstrName, "Move Source"); break; - case kHIDUsage_PID_MoveDestination: sprintf (cstrName, "Move Destination"); break; - case kHIDUsage_PID_MoveLength: sprintf (cstrName, "Move Length"); break; - - case kHIDUsage_PID_BlockLoadReport: sprintf (cstrName, "PID Block Load Report"); break; - - case kHIDUsage_PID_BlockLoadStatus: sprintf (cstrName, "Block Load Status"); break; - case kHIDUsage_PID_BlockLoadSuccess: sprintf (cstrName, "Block Load Success"); break; - case kHIDUsage_PID_BlockLoadFull: sprintf (cstrName, "Block Load Full"); break; - case kHIDUsage_PID_BlockLoadError: sprintf (cstrName, "Block Load Error"); break; - case kHIDUsage_PID_BlockHandle: sprintf (cstrName, "Block Handle"); break; - - case kHIDUsage_PID_BlockFreeReport: sprintf (cstrName, "PID Block Free Report"); break; - - case kHIDUsage_PID_TypeSpecificBlockHandle: sprintf (cstrName, "Type Specific Block Handle"); break; - - case kHIDUsage_PID_StateReport: sprintf (cstrName, "PID State Report"); break; - case kHIDUsage_PID_EffectPlaying: sprintf (cstrName, "Effect Playing"); break; - - case kHIDUsage_PID_DeviceControlReport: sprintf (cstrName, "PID Device Control Report"); break; - - case kHIDUsage_PID_DeviceControl: sprintf (cstrName, "PID Device Control"); break; - case kHIDUsage_PID_DC_EnableActuators: sprintf (cstrName, "Device Control Enable Actuators"); break; - case kHIDUsage_PID_DC_DisableActuators: sprintf (cstrName, "Device Control Disable Actuators"); break; - case kHIDUsage_PID_DC_StopAllEffects: sprintf (cstrName, "Device Control Stop All Effects"); break; - case kHIDUsage_PID_DC_DeviceReset: sprintf (cstrName, "Device Control Reset"); break; - case kHIDUsage_PID_DC_DevicePause: sprintf (cstrName, "Device Control Pause"); break; - case kHIDUsage_PID_DC_DeviceContinue: sprintf (cstrName, "Device Control Continue"); break; - case kHIDUsage_PID_DevicePaused: sprintf (cstrName, "Device Paused"); break; - case kHIDUsage_PID_ActuatorsEnabled: sprintf (cstrName, "Actuators Enabled"); break; - case kHIDUsage_PID_SafetySwitch: sprintf (cstrName, "Safety Switch"); break; - case kHIDUsage_PID_ActuatorOverrideSwitch: sprintf (cstrName, "Actuator Override Switch"); break; - case kHIDUsage_PID_ActuatorPower: sprintf (cstrName, "Actuator Power"); break; - case kHIDUsage_PID_StartDelay: sprintf (cstrName, "Start Delay"); break; - - case kHIDUsage_PID_ParameterBlockSize: sprintf (cstrName, "Parameter Block Size"); break; - case kHIDUsage_PID_DeviceManagedPool: sprintf (cstrName, "Device Managed Pool"); break; - case kHIDUsage_PID_SharedParameterBlocks: sprintf (cstrName, "Shared Parameter Blocks"); break; - - case kHIDUsage_PID_CreateNewEffectReport: sprintf (cstrName, "Create New Effect Report"); break; - case kHIDUsage_PID_RAM_PoolAvailable: sprintf (cstrName, "RAM Pool Available"); break; - default: sprintf (cstrName, "PID Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Unicode: - switch (element->usage) - { - default: sprintf (cstrName, "Unicode Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_PowerDevice: - if (((element->usage >= 0x06) && (element->usage <= 0x0F)) || ((element->usage >= 0x26) && (element->usage <= 0x2F)) || - ((element->usage >= 0x39) && (element->usage <= 0x3F)) || ((element->usage >= 0x48) && (element->usage <= 0x4F)) || - ((element->usage >= 0x58) && (element->usage <= 0x5F)) || (element->usage == 0x6A) || - ((element->usage >= 0x74) && (element->usage <= 0xFC))) - sprintf (cstrName, "Power Device Reserved"); - else - switch (element->usage) - { - case kHIDUsage_PD_Undefined: sprintf (cstrName, "Power Device Undefined Usage"); break; - case kHIDUsage_PD_iName: sprintf (cstrName, "Power Device Name Index"); break; - case kHIDUsage_PD_PresentStatus: sprintf (cstrName, "Power Device Present Status"); break; - case kHIDUsage_PD_ChangedStatus: sprintf (cstrName, "Power Device Changed Status"); break; - case kHIDUsage_PD_UPS: sprintf (cstrName, "Uninterruptible Power Supply"); break; - case kHIDUsage_PD_PowerSupply: sprintf (cstrName, "Power Supply"); break; - - case kHIDUsage_PD_BatterySystem: sprintf (cstrName, "Battery System Power Module"); break; - case kHIDUsage_PD_BatterySystemID: sprintf (cstrName, "Battery System ID"); break; - case kHIDUsage_PD_Battery: sprintf (cstrName, "Battery"); break; - case kHIDUsage_PD_BatteryID: sprintf (cstrName, "Battery ID"); break; - case kHIDUsage_PD_Charger: sprintf (cstrName, "Charger"); break; - case kHIDUsage_PD_ChargerID: sprintf (cstrName, "Charger ID"); break; - case kHIDUsage_PD_PowerConverter: sprintf (cstrName, "Power Converter Power Module"); break; - case kHIDUsage_PD_PowerConverterID: sprintf (cstrName, "Power Converter ID"); break; - case kHIDUsage_PD_OutletSystem: sprintf (cstrName, "Outlet System power module"); break; - case kHIDUsage_PD_OutletSystemID: sprintf (cstrName, "Outlet System ID"); break; - case kHIDUsage_PD_Input: sprintf (cstrName, "Power Device Input"); break; - case kHIDUsage_PD_InputID: sprintf (cstrName, "Power Device Input ID"); break; - case kHIDUsage_PD_Output: sprintf (cstrName, "Power Device Output"); break; - case kHIDUsage_PD_OutputID: sprintf (cstrName, "Power Device Output ID"); break; - case kHIDUsage_PD_Flow: sprintf (cstrName, "Power Device Flow"); break; - case kHIDUsage_PD_FlowID: sprintf (cstrName, "Power Device Flow ID"); break; - case kHIDUsage_PD_Outlet: sprintf (cstrName, "Power Device Outlet"); break; - case kHIDUsage_PD_OutletID: sprintf (cstrName, "Power Device Outlet ID"); break; - case kHIDUsage_PD_Gang: sprintf (cstrName, "Power Device Gang"); break; - case kHIDUsage_PD_GangID: sprintf (cstrName, "Power Device Gang ID"); break; - case kHIDUsage_PD_PowerSummary: sprintf (cstrName, "Power Device Power Summary"); break; - case kHIDUsage_PD_PowerSummaryID: sprintf (cstrName, "Power Device Power Summary ID"); break; - - case kHIDUsage_PD_Voltage: sprintf (cstrName, "Power Device Voltage"); break; - case kHIDUsage_PD_Current: sprintf (cstrName, "Power Device Current"); break; - case kHIDUsage_PD_Frequency: sprintf (cstrName, "Power Device Frequency"); break; - case kHIDUsage_PD_ApparentPower: sprintf (cstrName, "Power Device Apparent Power"); break; - case kHIDUsage_PD_ActivePower: sprintf (cstrName, "Power Device RMS Power"); break; - case kHIDUsage_PD_PercentLoad: sprintf (cstrName, "Power Device Percent Load"); break; - case kHIDUsage_PD_Temperature: sprintf (cstrName, "Power Device Temperature"); break; - case kHIDUsage_PD_Humidity: sprintf (cstrName, "Power Device Humidity"); break; - case kHIDUsage_PD_BadCount: sprintf (cstrName, "Power Device Bad Condition Count"); break; - - case kHIDUsage_PD_ConfigVoltage: sprintf (cstrName, "Power Device Nominal Voltage"); break; - case kHIDUsage_PD_ConfigCurrent: sprintf (cstrName, "Power Device Nominal Current"); break; - case kHIDUsage_PD_ConfigFrequency: sprintf (cstrName, "Power Device Nominal Frequency"); break; - case kHIDUsage_PD_ConfigApparentPower: sprintf (cstrName, "Power Device Nominal Apparent Power"); break; - case kHIDUsage_PD_ConfigActivePower: sprintf (cstrName, "Power Device Nominal RMS Power"); break; - case kHIDUsage_PD_ConfigPercentLoad: sprintf (cstrName, "Power Device Nominal Percent Load"); break; - case kHIDUsage_PD_ConfigTemperature: sprintf (cstrName, "Power Device Nominal Temperature"); break; - - case kHIDUsage_PD_ConfigHumidity: sprintf (cstrName, "Power Device Nominal Humidity"); break; - case kHIDUsage_PD_SwitchOnControl: sprintf (cstrName, "Power Device Switch On Control"); break; - case kHIDUsage_PD_SwitchOffControl: sprintf (cstrName, "Power Device Switch Off Control"); break; - case kHIDUsage_PD_ToggleControl: sprintf (cstrName, "Power Device Toogle Sequence Control"); break; - case kHIDUsage_PD_LowVoltageTransfer: sprintf (cstrName, "Power Device Min Transfer Voltage"); break; - case kHIDUsage_PD_HighVoltageTransfer: sprintf (cstrName, "Power Device Max Transfer Voltage"); break; - case kHIDUsage_PD_DelayBeforeReboot: sprintf (cstrName, "Power Device Delay Before Reboot"); break; - case kHIDUsage_PD_DelayBeforeStartup: sprintf (cstrName, "Power Device Delay Before Startup"); break; - case kHIDUsage_PD_DelayBeforeShutdown: sprintf (cstrName, "Power Device Delay Before Shutdown"); break; - case kHIDUsage_PD_Test: sprintf (cstrName, "Power Device Test Request/Result"); break; - case kHIDUsage_PD_ModuleReset: sprintf (cstrName, "Power Device Reset Request/Result"); break; - case kHIDUsage_PD_AudibleAlarmControl: sprintf (cstrName, "Power Device Audible Alarm Control"); break; - - case kHIDUsage_PD_Present: sprintf (cstrName, "Power Device Present"); break; - case kHIDUsage_PD_Good: sprintf (cstrName, "Power Device Good"); break; - case kHIDUsage_PD_InternalFailure: sprintf (cstrName, "Power Device Internal Failure"); break; - case kHIDUsage_PD_VoltageOutOfRange: sprintf (cstrName, "Power Device Voltage Out Of Range"); break; - case kHIDUsage_PD_FrequencyOutOfRange: sprintf (cstrName, "Power Device Frequency Out Of Range"); break; - case kHIDUsage_PD_Overload: sprintf (cstrName, "Power Device Overload"); break; - case kHIDUsage_PD_OverCharged: sprintf (cstrName, "Power Device Over Charged"); break; - case kHIDUsage_PD_OverTemperature: sprintf (cstrName, "Power Device Over Temperature"); break; - case kHIDUsage_PD_ShutdownRequested: sprintf (cstrName, "Power Device Shutdown Requested"); break; - - case kHIDUsage_PD_ShutdownImminent: sprintf (cstrName, "Power Device Shutdown Imminent"); break; - case kHIDUsage_PD_SwitchOnOff: sprintf (cstrName, "Power Device On/Off Switch Status"); break; - case kHIDUsage_PD_Switchable: sprintf (cstrName, "Power Device Switchable"); break; - case kHIDUsage_PD_Used: sprintf (cstrName, "Power Device Used"); break; - case kHIDUsage_PD_Boost: sprintf (cstrName, "Power Device Boosted"); break; - case kHIDUsage_PD_Buck: sprintf (cstrName, "Power Device Bucked"); break; - case kHIDUsage_PD_Initialized: sprintf (cstrName, "Power Device Initialized"); break; - case kHIDUsage_PD_Tested: sprintf (cstrName, "Power Device Tested"); break; - case kHIDUsage_PD_AwaitingPower: sprintf (cstrName, "Power Device Awaiting Power"); break; - case kHIDUsage_PD_CommunicationLost: sprintf (cstrName, "Power Device Communication Lost"); break; - - case kHIDUsage_PD_iManufacturer: sprintf (cstrName, "Power Device Manufacturer String Index"); break; - case kHIDUsage_PD_iProduct: sprintf (cstrName, "Power Device Product String Index"); break; - case kHIDUsage_PD_iserialNumber: sprintf (cstrName, "Power Device Serial Number String Index"); break; - default: sprintf (cstrName, "Power Device Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_BatterySystem: - if (((element->usage >= 0x0A) && (element->usage <= 0x0F)) || ((element->usage >= 0x1E) && (element->usage <= 0x27)) || - ((element->usage >= 0x30) && (element->usage <= 0x3F)) || ((element->usage >= 0x4C) && (element->usage <= 0x5F)) || - ((element->usage >= 0x6C) && (element->usage <= 0x7F)) || ((element->usage >= 0x90) && (element->usage <= 0xBF)) || - ((element->usage >= 0xC3) && (element->usage <= 0xCF)) || ((element->usage >= 0xDD) && (element->usage <= 0xEF)) || - ((element->usage >= 0xF2) && (element->usage <= 0xFF))) - sprintf (cstrName, "Power Device Reserved"); - else - switch (element->usage) - { - case kHIDUsage_BS_Undefined: sprintf (cstrName, "Battery System Undefined"); break; - case kHIDUsage_BS_SMBBatteryMode: sprintf (cstrName, "SMB Mode"); break; - case kHIDUsage_BS_SMBBatteryStatus: sprintf (cstrName, "SMB Status"); break; - case kHIDUsage_BS_SMBAlarmWarning: sprintf (cstrName, "SMB Alarm Warning"); break; - case kHIDUsage_BS_SMBChargerMode: sprintf (cstrName, "SMB Charger Mode"); break; - case kHIDUsage_BS_SMBChargerStatus: sprintf (cstrName, "SMB Charger Status"); break; - case kHIDUsage_BS_SMBChargerSpecInfo: sprintf (cstrName, "SMB Charger Extended Status"); break; - case kHIDUsage_BS_SMBSelectorState: sprintf (cstrName, "SMB Selector State"); break; - case kHIDUsage_BS_SMBSelectorPresets: sprintf (cstrName, "SMB Selector Presets"); break; - case kHIDUsage_BS_SMBSelectorInfo: sprintf (cstrName, "SMB Selector Info"); break; - case kHIDUsage_BS_OptionalMfgFunction1: sprintf (cstrName, "Battery System Optional SMB Mfg Function 1"); break; - case kHIDUsage_BS_OptionalMfgFunction2: sprintf (cstrName, "Battery System Optional SMB Mfg Function 2"); break; - case kHIDUsage_BS_OptionalMfgFunction3: sprintf (cstrName, "Battery System Optional SMB Mfg Function 3"); break; - case kHIDUsage_BS_OptionalMfgFunction4: sprintf (cstrName, "Battery System Optional SMB Mfg Function 4"); break; - case kHIDUsage_BS_OptionalMfgFunction5: sprintf (cstrName, "Battery System Optional SMB Mfg Function 5"); break; - case kHIDUsage_BS_ConnectionToSMBus: sprintf (cstrName, "Battery System Connection To System Management Bus"); break; - case kHIDUsage_BS_OutputConnection: sprintf (cstrName, "Battery System Output Connection Status"); break; - case kHIDUsage_BS_ChargerConnection: sprintf (cstrName, "Battery System Charger Connection"); break; - case kHIDUsage_BS_BatteryInsertion: sprintf (cstrName, "Battery System Battery Insertion"); break; - case kHIDUsage_BS_Usenext: sprintf (cstrName, "Battery System Use Next"); break; - case kHIDUsage_BS_OKToUse: sprintf (cstrName, "Battery System OK To Use"); break; - case kHIDUsage_BS_BatterySupported: sprintf (cstrName, "Battery System Battery Supported"); break; - case kHIDUsage_BS_SelectorRevision: sprintf (cstrName, "Battery System Selector Revision"); break; - case kHIDUsage_BS_ChargingIndicator: sprintf (cstrName, "Battery System Charging Indicator"); break; - case kHIDUsage_BS_ManufacturerAccess: sprintf (cstrName, "Battery System Manufacturer Access"); break; - case kHIDUsage_BS_RemainingCapacityLimit: sprintf (cstrName, "Battery System Remaining Capacity Limit"); break; - case kHIDUsage_BS_RemainingTimeLimit: sprintf (cstrName, "Battery System Remaining Time Limit"); break; - case kHIDUsage_BS_AtRate: sprintf (cstrName, "Battery System At Rate..."); break; - case kHIDUsage_BS_CapacityMode: sprintf (cstrName, "Battery System Capacity Mode"); break; - case kHIDUsage_BS_BroadcastToCharger: sprintf (cstrName, "Battery System Broadcast To Charger"); break; - case kHIDUsage_BS_PrimaryBattery: sprintf (cstrName, "Battery System Primary Battery"); break; - case kHIDUsage_BS_ChargeController: sprintf (cstrName, "Battery System Charge Controller"); break; - case kHIDUsage_BS_TerminateCharge: sprintf (cstrName, "Battery System Terminate Charge"); break; - case kHIDUsage_BS_TerminateDischarge: sprintf (cstrName, "Battery System Terminate Discharge"); break; - case kHIDUsage_BS_BelowRemainingCapacityLimit: sprintf (cstrName, "Battery System Below Remaining Capacity Limit"); break; - case kHIDUsage_BS_RemainingTimeLimitExpired: sprintf (cstrName, "Battery System Remaining Time Limit Expired"); break; - case kHIDUsage_BS_Charging: sprintf (cstrName, "Battery System Charging"); break; - case kHIDUsage_BS_Discharging: sprintf (cstrName, "Battery System Discharging"); break; - case kHIDUsage_BS_FullyCharged: sprintf (cstrName, "Battery System Fully Charged"); break; - case kHIDUsage_BS_FullyDischarged: sprintf (cstrName, "Battery System Fully Discharged"); break; - case kHIDUsage_BS_ConditioningFlag: sprintf (cstrName, "Battery System Conditioning Flag"); break; - case kHIDUsage_BS_AtRateOK: sprintf (cstrName, "Battery System At Rate OK"); break; - case kHIDUsage_BS_SMBErrorCode: sprintf (cstrName, "Battery System SMB Error Code"); break; - case kHIDUsage_BS_NeedReplacement: sprintf (cstrName, "Battery System Need Replacement"); break; - case kHIDUsage_BS_AtRateTimeToFull: sprintf (cstrName, "Battery System At Rate Time To Full"); break; - case kHIDUsage_BS_AtRateTimeToEmpty: sprintf (cstrName, "Battery System At Rate Time To Empty"); break; - case kHIDUsage_BS_AverageCurrent: sprintf (cstrName, "Battery System Average Current"); break; - case kHIDUsage_BS_Maxerror: sprintf (cstrName, "Battery System Max Error"); break; - case kHIDUsage_BS_RelativeStateOfCharge: sprintf (cstrName, "Battery System Relative State Of Charge"); break; - case kHIDUsage_BS_AbsoluteStateOfCharge: sprintf (cstrName, "Battery System Absolute State Of Charge"); break; - case kHIDUsage_BS_RemainingCapacity: sprintf (cstrName, "Battery System Remaining Capacity"); break; - case kHIDUsage_BS_FullChargeCapacity: sprintf (cstrName, "Battery System Full Charge Capacity"); break; - case kHIDUsage_BS_RunTimeToEmpty: sprintf (cstrName, "Battery System Run Time To Empty"); break; - case kHIDUsage_BS_AverageTimeToEmpty: sprintf (cstrName, "Battery System Average Time To Empty"); break; - case kHIDUsage_BS_AverageTimeToFull: sprintf (cstrName, "Battery System Average Time To Full"); break; - case kHIDUsage_BS_CycleCount: sprintf (cstrName, "Battery System Cycle Count"); break; - case kHIDUsage_BS_BattPackModelLevel: sprintf (cstrName, "Battery System Batt Pack Model Level"); break; - case kHIDUsage_BS_InternalChargeController: sprintf (cstrName, "Battery System Internal Charge Controller"); break; - case kHIDUsage_BS_PrimaryBatterySupport: sprintf (cstrName, "Battery System Primary Battery Support"); break; - case kHIDUsage_BS_DesignCapacity: sprintf (cstrName, "Battery System Design Capacity"); break; - case kHIDUsage_BS_SpecificationInfo: sprintf (cstrName, "Battery System Specification Info"); break; - case kHIDUsage_BS_ManufacturerDate: sprintf (cstrName, "Battery System Manufacturer Date"); break; - case kHIDUsage_BS_SerialNumber: sprintf (cstrName, "Battery System Serial Number"); break; - case kHIDUsage_BS_iManufacturerName: sprintf (cstrName, "Battery System Manufacturer Name Index"); break; - case kHIDUsage_BS_iDevicename: sprintf (cstrName, "Battery System Device Name Index"); break; - case kHIDUsage_BS_iDeviceChemistry: sprintf (cstrName, "Battery System Device Chemistry Index"); break; - case kHIDUsage_BS_ManufacturerData: sprintf (cstrName, "Battery System Manufacturer Data"); break; - case kHIDUsage_BS_Rechargable: sprintf (cstrName, "Battery System Rechargable"); break; - case kHIDUsage_BS_WarningCapacityLimit: sprintf (cstrName, "Battery System Warning Capacity Limit"); break; - case kHIDUsage_BS_CapacityGranularity1: sprintf (cstrName, "Battery System Capacity Granularity 1"); break; - case kHIDUsage_BS_CapacityGranularity2: sprintf (cstrName, "Battery System Capacity Granularity 2"); break; - case kHIDUsage_BS_iOEMInformation: sprintf (cstrName, "Battery System OEM Information Index"); break; - case kHIDUsage_BS_InhibitCharge: sprintf (cstrName, "Battery System Inhibit Charge"); break; - case kHIDUsage_BS_EnablePolling: sprintf (cstrName, "Battery System Enable Polling"); break; - case kHIDUsage_BS_ResetToZero: sprintf (cstrName, "Battery System Reset To Zero"); break; - case kHIDUsage_BS_ACPresent: sprintf (cstrName, "Battery System AC Present"); break; - case kHIDUsage_BS_BatteryPresent: sprintf (cstrName, "Battery System Battery Present"); break; - case kHIDUsage_BS_PowerFail: sprintf (cstrName, "Battery System Power Fail"); break; - case kHIDUsage_BS_AlarmInhibited: sprintf (cstrName, "Battery System Alarm Inhibited"); break; - case kHIDUsage_BS_ThermistorUnderRange: sprintf (cstrName, "Battery System Thermistor Under Range"); break; - case kHIDUsage_BS_ThermistorHot: sprintf (cstrName, "Battery System Thermistor Hot"); break; - case kHIDUsage_BS_ThermistorCold: sprintf (cstrName, "Battery System Thermistor Cold"); break; - case kHIDUsage_BS_ThermistorOverRange: sprintf (cstrName, "Battery System Thermistor Over Range"); break; - case kHIDUsage_BS_VoltageOutOfRange: sprintf (cstrName, "Battery System Voltage Out Of Range"); break; - case kHIDUsage_BS_CurrentOutOfRange: sprintf (cstrName, "Battery System Current Out Of Range"); break; - case kHIDUsage_BS_CurrentNotRegulated: sprintf (cstrName, "Battery System Current Not Regulated"); break; - case kHIDUsage_BS_VoltageNotRegulated: sprintf (cstrName, "Battery System Voltage Not Regulated"); break; - case kHIDUsage_BS_MasterMode: sprintf (cstrName, "Battery System Master Mode"); break; - case kHIDUsage_BS_ChargerSelectorSupport: sprintf (cstrName, "Battery System Charger Support Selector"); break; - case kHIDUsage_BS_ChargerSpec: sprintf (cstrName, "attery System Charger Specification"); break; - case kHIDUsage_BS_Level2: sprintf (cstrName, "Battery System Charger Level 2"); break; - case kHIDUsage_BS_Level3: sprintf (cstrName, "Battery System Charger Level 3"); break; - default: sprintf (cstrName, "Battery System Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_AlphanumericDisplay: - switch (element->usage) - { - default: sprintf (cstrName, "Alphanumeric Display Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_BarCodeScanner: - switch (element->usage) - { - default: sprintf (cstrName, "Bar Code Scanner Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Scale: - switch (element->usage) - { - default: sprintf (cstrName, "Scale Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_CameraControl: - switch (element->usage) - { - default: sprintf (cstrName, "Camera Control Usage 0x%lx", element->usage); break; - } - break; - case kHIDPage_Arcade: - switch (element->usage) - { - default: sprintf (cstrName, "Arcade Usage 0x%lx", element->usage); break; - } - break; - default: - if (element->usagePage > kHIDPage_VendorDefinedStart) - sprintf (cstrName, "Vendor Defined Usage 0x%lx", element->usage); - else - sprintf (cstrName, "Page: 0x%lx, Usage: 0x%lx", element->usagePage, element->usage); - break; + { + case 0x00: sprintf (cstrName, "PID Undefined Usage"); break; + case kHIDUsage_PID_PhysicalInterfaceDevice: sprintf (cstrName, "Physical Interface Device"); break; + case kHIDUsage_PID_Normal: sprintf (cstrName, "Normal Force"); break; + + case kHIDUsage_PID_SetEffectReport: sprintf (cstrName, "Set Effect Report"); break; + case kHIDUsage_PID_EffectBlockIndex: sprintf (cstrName, "Effect Block Index"); break; + case kHIDUsage_PID_ParamBlockOffset: sprintf (cstrName, "Parameter Block Offset"); break; + case kHIDUsage_PID_ROM_Flag: sprintf (cstrName, "ROM Flag"); break; + + case kHIDUsage_PID_EffectType: sprintf (cstrName, "Effect Type"); break; + case kHIDUsage_PID_ET_ConstantForce: sprintf (cstrName, "Effect Type Constant Force"); break; + case kHIDUsage_PID_ET_Ramp: sprintf (cstrName, "Effect Type Ramp"); break; + case kHIDUsage_PID_ET_CustomForceData: sprintf (cstrName, "Effect Type Custom Force Data"); break; + case kHIDUsage_PID_ET_Square: sprintf (cstrName, "Effect Type Square"); break; + case kHIDUsage_PID_ET_Sine: sprintf (cstrName, "Effect Type Sine"); break; + case kHIDUsage_PID_ET_Triangle: sprintf (cstrName, "Effect Type Triangle"); break; + case kHIDUsage_PID_ET_SawtoothUp: sprintf (cstrName, "Effect Type Sawtooth Up"); break; + case kHIDUsage_PID_ET_SawtoothDown: sprintf (cstrName, "Effect Type Sawtooth Down"); break; + case kHIDUsage_PID_ET_Spring: sprintf (cstrName, "Effect Type Spring"); break; + case kHIDUsage_PID_ET_Damper: sprintf (cstrName, "Effect Type Damper"); break; + case kHIDUsage_PID_ET_Inertia: sprintf (cstrName, "Effect Type Inertia"); break; + case kHIDUsage_PID_ET_Friction: sprintf (cstrName, "Effect Type Friction"); break; + case kHIDUsage_PID_Duration: sprintf (cstrName, "Effect Duration"); break; + case kHIDUsage_PID_SamplePeriod: sprintf (cstrName, "Effect Sample Period"); break; + case kHIDUsage_PID_Gain: sprintf (cstrName, "Effect Gain"); break; + case kHIDUsage_PID_TriggerButton: sprintf (cstrName, "Effect Trigger Button"); break; + case kHIDUsage_PID_TriggerRepeatInterval: sprintf (cstrName, "Effect Trigger Repeat Interval"); break; + + case kHIDUsage_PID_AxesEnable: sprintf (cstrName, "Axis Enable"); break; + case kHIDUsage_PID_DirectionEnable: sprintf (cstrName, "Direction Enable"); break; + + case kHIDUsage_PID_Direction: sprintf (cstrName, "Direction"); break; + + case kHIDUsage_PID_TypeSpecificBlockOffset: sprintf (cstrName, "Type Specific Block Offset"); break; + + case kHIDUsage_PID_BlockType: sprintf (cstrName, "Block Type"); break; + + case kHIDUsage_PID_SetEnvelopeReport: sprintf (cstrName, "Set Envelope Report"); break; + case kHIDUsage_PID_AttackLevel: sprintf (cstrName, "Envelope Attack Level"); break; + case kHIDUsage_PID_AttackTime: sprintf (cstrName, "Envelope Attack Time"); break; + case kHIDUsage_PID_FadeLevel: sprintf (cstrName, "Envelope Fade Level"); break; + case kHIDUsage_PID_FadeTime: sprintf (cstrName, "Envelope Fade Time"); break; + + case kHIDUsage_PID_SetConditionReport: sprintf (cstrName, "Set Condition Report"); break; + case kHIDUsage_PID_CP_Offset: sprintf (cstrName, "Condition CP Offset"); break; + case kHIDUsage_PID_PositiveCoefficient: sprintf (cstrName, "Condition Positive Coefficient"); break; + case kHIDUsage_PID_NegativeCoefficient: sprintf (cstrName, "Condition Negative Coefficient"); break; + case kHIDUsage_PID_PositiveSaturation: sprintf (cstrName, "Condition Positive Saturation"); break; + case kHIDUsage_PID_NegativeSaturation: sprintf (cstrName, "Condition Negative Saturation"); break; + case kHIDUsage_PID_DeadBand: sprintf (cstrName, "Condition Dead Band"); break; + + case kHIDUsage_PID_DownloadForceSample: sprintf (cstrName, "Download Force Sample"); break; + case kHIDUsage_PID_IsochCustomForceEnable: sprintf (cstrName, "Isoch Custom Force Enable"); break; + + case kHIDUsage_PID_CustomForceDataReport: sprintf (cstrName, "Custom Force Data Report"); break; + case kHIDUsage_PID_CustomForceData: sprintf (cstrName, "Custom Force Data"); break; + + case kHIDUsage_PID_CustomForceVendorDefinedData: sprintf (cstrName, "Custom Force Vendor Defined Data"); break; + case kHIDUsage_PID_SetCustomForceReport: sprintf (cstrName, "Set Custom Force Report"); break; + case kHIDUsage_PID_CustomForceDataOffset: sprintf (cstrName, "Custom Force Data Offset"); break; + case kHIDUsage_PID_SampleCount: sprintf (cstrName, "Custom Force Sample Count"); break; + + case kHIDUsage_PID_SetPeriodicReport: sprintf (cstrName, "Set Periodic Report"); break; + case kHIDUsage_PID_Offset: sprintf (cstrName, "Periodic Offset"); break; + case kHIDUsage_PID_Magnitude: sprintf (cstrName, "Periodic Magnitude"); break; + case kHIDUsage_PID_Phase: sprintf (cstrName, "Periodic Phase"); break; + case kHIDUsage_PID_Period: sprintf (cstrName, "Periodic Period"); break; + + case kHIDUsage_PID_SetConstantForceReport: sprintf (cstrName, "Set Constant Force Report"); break; + + case kHIDUsage_PID_SetRampForceReport: sprintf (cstrName, "Set Ramp Force Report"); break; + case kHIDUsage_PID_RampStart: sprintf (cstrName, "Ramp Start"); break; + case kHIDUsage_PID_RampEnd: sprintf (cstrName, "Ramp End"); break; + + case kHIDUsage_PID_EffectOperationReport: sprintf (cstrName, "Effect Operation Report"); break; + + case kHIDUsage_PID_EffectOperation: sprintf (cstrName, "Effect Operation"); break; + case kHIDUsage_PID_OpEffectStart: sprintf (cstrName, "Op Effect Start"); break; + case kHIDUsage_PID_OpEffectStartSolo: sprintf (cstrName, "Op Effect Start Solo"); break; + case kHIDUsage_PID_OpEffectStop: sprintf (cstrName, "Op Effect Stop"); break; + case kHIDUsage_PID_LoopCount: sprintf (cstrName, "Op Effect Loop Count"); break; + + case kHIDUsage_PID_DeviceGainReport: sprintf (cstrName, "Device Gain Report"); break; + case kHIDUsage_PID_DeviceGain: sprintf (cstrName, "Device Gain"); break; + + case kHIDUsage_PID_PoolReport: sprintf (cstrName, "PID Pool Report"); break; + case kHIDUsage_PID_RAM_PoolSize: sprintf (cstrName, "RAM Pool Size"); break; + case kHIDUsage_PID_ROM_PoolSize: sprintf (cstrName, "ROM Pool Size"); break; + case kHIDUsage_PID_ROM_EffectBlockCount: sprintf (cstrName, "ROM Effect Block Count"); break; + case kHIDUsage_PID_SimultaneousEffectsMax: sprintf (cstrName, "Simultaneous Effects Max"); break; + case kHIDUsage_PID_PoolAlignment: sprintf (cstrName, "Pool Alignment"); break; + + case kHIDUsage_PID_PoolMoveReport: sprintf (cstrName, "PID Pool Move Report"); break; + case kHIDUsage_PID_MoveSource: sprintf (cstrName, "Move Source"); break; + case kHIDUsage_PID_MoveDestination: sprintf (cstrName, "Move Destination"); break; + case kHIDUsage_PID_MoveLength: sprintf (cstrName, "Move Length"); break; + + case kHIDUsage_PID_BlockLoadReport: sprintf (cstrName, "PID Block Load Report"); break; + + case kHIDUsage_PID_BlockLoadStatus: sprintf (cstrName, "Block Load Status"); break; + case kHIDUsage_PID_BlockLoadSuccess: sprintf (cstrName, "Block Load Success"); break; + case kHIDUsage_PID_BlockLoadFull: sprintf (cstrName, "Block Load Full"); break; + case kHIDUsage_PID_BlockLoadError: sprintf (cstrName, "Block Load Error"); break; + case kHIDUsage_PID_BlockHandle: sprintf (cstrName, "Block Handle"); break; + + case kHIDUsage_PID_BlockFreeReport: sprintf (cstrName, "PID Block Free Report"); break; + + case kHIDUsage_PID_TypeSpecificBlockHandle: sprintf (cstrName, "Type Specific Block Handle"); break; + + case kHIDUsage_PID_StateReport: sprintf (cstrName, "PID State Report"); break; + case kHIDUsage_PID_EffectPlaying: sprintf (cstrName, "Effect Playing"); break; + + case kHIDUsage_PID_DeviceControlReport: sprintf (cstrName, "PID Device Control Report"); break; + + case kHIDUsage_PID_DeviceControl: sprintf (cstrName, "PID Device Control"); break; + case kHIDUsage_PID_DC_EnableActuators: sprintf (cstrName, "Device Control Enable Actuators"); break; + case kHIDUsage_PID_DC_DisableActuators: sprintf (cstrName, "Device Control Disable Actuators"); break; + case kHIDUsage_PID_DC_StopAllEffects: sprintf (cstrName, "Device Control Stop All Effects"); break; + case kHIDUsage_PID_DC_DeviceReset: sprintf (cstrName, "Device Control Reset"); break; + case kHIDUsage_PID_DC_DevicePause: sprintf (cstrName, "Device Control Pause"); break; + case kHIDUsage_PID_DC_DeviceContinue: sprintf (cstrName, "Device Control Continue"); break; + case kHIDUsage_PID_DevicePaused: sprintf (cstrName, "Device Paused"); break; + case kHIDUsage_PID_ActuatorsEnabled: sprintf (cstrName, "Actuators Enabled"); break; + case kHIDUsage_PID_SafetySwitch: sprintf (cstrName, "Safety Switch"); break; + case kHIDUsage_PID_ActuatorOverrideSwitch: sprintf (cstrName, "Actuator Override Switch"); break; + case kHIDUsage_PID_ActuatorPower: sprintf (cstrName, "Actuator Power"); break; + case kHIDUsage_PID_StartDelay: sprintf (cstrName, "Start Delay"); break; + + case kHIDUsage_PID_ParameterBlockSize: sprintf (cstrName, "Parameter Block Size"); break; + case kHIDUsage_PID_DeviceManagedPool: sprintf (cstrName, "Device Managed Pool"); break; + case kHIDUsage_PID_SharedParameterBlocks: sprintf (cstrName, "Shared Parameter Blocks"); break; + + case kHIDUsage_PID_CreateNewEffectReport: sprintf (cstrName, "Create New Effect Report"); break; + case kHIDUsage_PID_RAM_PoolAvailable: sprintf (cstrName, "RAM Pool Available"); break; + default: sprintf (cstrName, "PID Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Unicode: + switch (element->usage) + { + default: sprintf (cstrName, "Unicode Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_PowerDevice: + if (((element->usage >= 0x06) && (element->usage <= 0x0F)) || ((element->usage >= 0x26) && (element->usage <= 0x2F)) || + ((element->usage >= 0x39) && (element->usage <= 0x3F)) || ((element->usage >= 0x48) && (element->usage <= 0x4F)) || + ((element->usage >= 0x58) && (element->usage <= 0x5F)) || (element->usage == 0x6A) || + ((element->usage >= 0x74) && (element->usage <= 0xFC))) + sprintf (cstrName, "Power Device Reserved"); + else + switch (element->usage) + { + case kHIDUsage_PD_Undefined: sprintf (cstrName, "Power Device Undefined Usage"); break; + case kHIDUsage_PD_iName: sprintf (cstrName, "Power Device Name Index"); break; + case kHIDUsage_PD_PresentStatus: sprintf (cstrName, "Power Device Present Status"); break; + case kHIDUsage_PD_ChangedStatus: sprintf (cstrName, "Power Device Changed Status"); break; + case kHIDUsage_PD_UPS: sprintf (cstrName, "Uninterruptible Power Supply"); break; + case kHIDUsage_PD_PowerSupply: sprintf (cstrName, "Power Supply"); break; + + case kHIDUsage_PD_BatterySystem: sprintf (cstrName, "Battery System Power Module"); break; + case kHIDUsage_PD_BatterySystemID: sprintf (cstrName, "Battery System ID"); break; + case kHIDUsage_PD_Battery: sprintf (cstrName, "Battery"); break; + case kHIDUsage_PD_BatteryID: sprintf (cstrName, "Battery ID"); break; + case kHIDUsage_PD_Charger: sprintf (cstrName, "Charger"); break; + case kHIDUsage_PD_ChargerID: sprintf (cstrName, "Charger ID"); break; + case kHIDUsage_PD_PowerConverter: sprintf (cstrName, "Power Converter Power Module"); break; + case kHIDUsage_PD_PowerConverterID: sprintf (cstrName, "Power Converter ID"); break; + case kHIDUsage_PD_OutletSystem: sprintf (cstrName, "Outlet System power module"); break; + case kHIDUsage_PD_OutletSystemID: sprintf (cstrName, "Outlet System ID"); break; + case kHIDUsage_PD_Input: sprintf (cstrName, "Power Device Input"); break; + case kHIDUsage_PD_InputID: sprintf (cstrName, "Power Device Input ID"); break; + case kHIDUsage_PD_Output: sprintf (cstrName, "Power Device Output"); break; + case kHIDUsage_PD_OutputID: sprintf (cstrName, "Power Device Output ID"); break; + case kHIDUsage_PD_Flow: sprintf (cstrName, "Power Device Flow"); break; + case kHIDUsage_PD_FlowID: sprintf (cstrName, "Power Device Flow ID"); break; + case kHIDUsage_PD_Outlet: sprintf (cstrName, "Power Device Outlet"); break; + case kHIDUsage_PD_OutletID: sprintf (cstrName, "Power Device Outlet ID"); break; + case kHIDUsage_PD_Gang: sprintf (cstrName, "Power Device Gang"); break; + case kHIDUsage_PD_GangID: sprintf (cstrName, "Power Device Gang ID"); break; + case kHIDUsage_PD_PowerSummary: sprintf (cstrName, "Power Device Power Summary"); break; + case kHIDUsage_PD_PowerSummaryID: sprintf (cstrName, "Power Device Power Summary ID"); break; + + case kHIDUsage_PD_Voltage: sprintf (cstrName, "Power Device Voltage"); break; + case kHIDUsage_PD_Current: sprintf (cstrName, "Power Device Current"); break; + case kHIDUsage_PD_Frequency: sprintf (cstrName, "Power Device Frequency"); break; + case kHIDUsage_PD_ApparentPower: sprintf (cstrName, "Power Device Apparent Power"); break; + case kHIDUsage_PD_ActivePower: sprintf (cstrName, "Power Device RMS Power"); break; + case kHIDUsage_PD_PercentLoad: sprintf (cstrName, "Power Device Percent Load"); break; + case kHIDUsage_PD_Temperature: sprintf (cstrName, "Power Device Temperature"); break; + case kHIDUsage_PD_Humidity: sprintf (cstrName, "Power Device Humidity"); break; + case kHIDUsage_PD_BadCount: sprintf (cstrName, "Power Device Bad Condition Count"); break; + + case kHIDUsage_PD_ConfigVoltage: sprintf (cstrName, "Power Device Nominal Voltage"); break; + case kHIDUsage_PD_ConfigCurrent: sprintf (cstrName, "Power Device Nominal Current"); break; + case kHIDUsage_PD_ConfigFrequency: sprintf (cstrName, "Power Device Nominal Frequency"); break; + case kHIDUsage_PD_ConfigApparentPower: sprintf (cstrName, "Power Device Nominal Apparent Power"); break; + case kHIDUsage_PD_ConfigActivePower: sprintf (cstrName, "Power Device Nominal RMS Power"); break; + case kHIDUsage_PD_ConfigPercentLoad: sprintf (cstrName, "Power Device Nominal Percent Load"); break; + case kHIDUsage_PD_ConfigTemperature: sprintf (cstrName, "Power Device Nominal Temperature"); break; + + case kHIDUsage_PD_ConfigHumidity: sprintf (cstrName, "Power Device Nominal Humidity"); break; + case kHIDUsage_PD_SwitchOnControl: sprintf (cstrName, "Power Device Switch On Control"); break; + case kHIDUsage_PD_SwitchOffControl: sprintf (cstrName, "Power Device Switch Off Control"); break; + case kHIDUsage_PD_ToggleControl: sprintf (cstrName, "Power Device Toogle Sequence Control"); break; + case kHIDUsage_PD_LowVoltageTransfer: sprintf (cstrName, "Power Device Min Transfer Voltage"); break; + case kHIDUsage_PD_HighVoltageTransfer: sprintf (cstrName, "Power Device Max Transfer Voltage"); break; + case kHIDUsage_PD_DelayBeforeReboot: sprintf (cstrName, "Power Device Delay Before Reboot"); break; + case kHIDUsage_PD_DelayBeforeStartup: sprintf (cstrName, "Power Device Delay Before Startup"); break; + case kHIDUsage_PD_DelayBeforeShutdown: sprintf (cstrName, "Power Device Delay Before Shutdown"); break; + case kHIDUsage_PD_Test: sprintf (cstrName, "Power Device Test Request/Result"); break; + case kHIDUsage_PD_ModuleReset: sprintf (cstrName, "Power Device Reset Request/Result"); break; + case kHIDUsage_PD_AudibleAlarmControl: sprintf (cstrName, "Power Device Audible Alarm Control"); break; + + case kHIDUsage_PD_Present: sprintf (cstrName, "Power Device Present"); break; + case kHIDUsage_PD_Good: sprintf (cstrName, "Power Device Good"); break; + case kHIDUsage_PD_InternalFailure: sprintf (cstrName, "Power Device Internal Failure"); break; + case kHIDUsage_PD_VoltageOutOfRange: sprintf (cstrName, "Power Device Voltage Out Of Range"); break; + case kHIDUsage_PD_FrequencyOutOfRange: sprintf (cstrName, "Power Device Frequency Out Of Range"); break; + case kHIDUsage_PD_Overload: sprintf (cstrName, "Power Device Overload"); break; + case kHIDUsage_PD_OverCharged: sprintf (cstrName, "Power Device Over Charged"); break; + case kHIDUsage_PD_OverTemperature: sprintf (cstrName, "Power Device Over Temperature"); break; + case kHIDUsage_PD_ShutdownRequested: sprintf (cstrName, "Power Device Shutdown Requested"); break; + + case kHIDUsage_PD_ShutdownImminent: sprintf (cstrName, "Power Device Shutdown Imminent"); break; + case kHIDUsage_PD_SwitchOnOff: sprintf (cstrName, "Power Device On/Off Switch Status"); break; + case kHIDUsage_PD_Switchable: sprintf (cstrName, "Power Device Switchable"); break; + case kHIDUsage_PD_Used: sprintf (cstrName, "Power Device Used"); break; + case kHIDUsage_PD_Boost: sprintf (cstrName, "Power Device Boosted"); break; + case kHIDUsage_PD_Buck: sprintf (cstrName, "Power Device Bucked"); break; + case kHIDUsage_PD_Initialized: sprintf (cstrName, "Power Device Initialized"); break; + case kHIDUsage_PD_Tested: sprintf (cstrName, "Power Device Tested"); break; + case kHIDUsage_PD_AwaitingPower: sprintf (cstrName, "Power Device Awaiting Power"); break; + case kHIDUsage_PD_CommunicationLost: sprintf (cstrName, "Power Device Communication Lost"); break; + + case kHIDUsage_PD_iManufacturer: sprintf (cstrName, "Power Device Manufacturer String Index"); break; + case kHIDUsage_PD_iProduct: sprintf (cstrName, "Power Device Product String Index"); break; + case kHIDUsage_PD_iserialNumber: sprintf (cstrName, "Power Device Serial Number String Index"); break; + default: sprintf (cstrName, "Power Device Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_BatterySystem: + if (((element->usage >= 0x0A) && (element->usage <= 0x0F)) || ((element->usage >= 0x1E) && (element->usage <= 0x27)) || + ((element->usage >= 0x30) && (element->usage <= 0x3F)) || ((element->usage >= 0x4C) && (element->usage <= 0x5F)) || + ((element->usage >= 0x6C) && (element->usage <= 0x7F)) || ((element->usage >= 0x90) && (element->usage <= 0xBF)) || + ((element->usage >= 0xC3) && (element->usage <= 0xCF)) || ((element->usage >= 0xDD) && (element->usage <= 0xEF)) || + ((element->usage >= 0xF2) && (element->usage <= 0xFF))) + sprintf (cstrName, "Power Device Reserved"); + else + switch (element->usage) + { + case kHIDUsage_BS_Undefined: sprintf (cstrName, "Battery System Undefined"); break; + case kHIDUsage_BS_SMBBatteryMode: sprintf (cstrName, "SMB Mode"); break; + case kHIDUsage_BS_SMBBatteryStatus: sprintf (cstrName, "SMB Status"); break; + case kHIDUsage_BS_SMBAlarmWarning: sprintf (cstrName, "SMB Alarm Warning"); break; + case kHIDUsage_BS_SMBChargerMode: sprintf (cstrName, "SMB Charger Mode"); break; + case kHIDUsage_BS_SMBChargerStatus: sprintf (cstrName, "SMB Charger Status"); break; + case kHIDUsage_BS_SMBChargerSpecInfo: sprintf (cstrName, "SMB Charger Extended Status"); break; + case kHIDUsage_BS_SMBSelectorState: sprintf (cstrName, "SMB Selector State"); break; + case kHIDUsage_BS_SMBSelectorPresets: sprintf (cstrName, "SMB Selector Presets"); break; + case kHIDUsage_BS_SMBSelectorInfo: sprintf (cstrName, "SMB Selector Info"); break; + case kHIDUsage_BS_OptionalMfgFunction1: sprintf (cstrName, "Battery System Optional SMB Mfg Function 1"); break; + case kHIDUsage_BS_OptionalMfgFunction2: sprintf (cstrName, "Battery System Optional SMB Mfg Function 2"); break; + case kHIDUsage_BS_OptionalMfgFunction3: sprintf (cstrName, "Battery System Optional SMB Mfg Function 3"); break; + case kHIDUsage_BS_OptionalMfgFunction4: sprintf (cstrName, "Battery System Optional SMB Mfg Function 4"); break; + case kHIDUsage_BS_OptionalMfgFunction5: sprintf (cstrName, "Battery System Optional SMB Mfg Function 5"); break; + case kHIDUsage_BS_ConnectionToSMBus: sprintf (cstrName, "Battery System Connection To System Management Bus"); break; + case kHIDUsage_BS_OutputConnection: sprintf (cstrName, "Battery System Output Connection Status"); break; + case kHIDUsage_BS_ChargerConnection: sprintf (cstrName, "Battery System Charger Connection"); break; + case kHIDUsage_BS_BatteryInsertion: sprintf (cstrName, "Battery System Battery Insertion"); break; + case kHIDUsage_BS_Usenext: sprintf (cstrName, "Battery System Use Next"); break; + case kHIDUsage_BS_OKToUse: sprintf (cstrName, "Battery System OK To Use"); break; + case kHIDUsage_BS_BatterySupported: sprintf (cstrName, "Battery System Battery Supported"); break; + case kHIDUsage_BS_SelectorRevision: sprintf (cstrName, "Battery System Selector Revision"); break; + case kHIDUsage_BS_ChargingIndicator: sprintf (cstrName, "Battery System Charging Indicator"); break; + case kHIDUsage_BS_ManufacturerAccess: sprintf (cstrName, "Battery System Manufacturer Access"); break; + case kHIDUsage_BS_RemainingCapacityLimit: sprintf (cstrName, "Battery System Remaining Capacity Limit"); break; + case kHIDUsage_BS_RemainingTimeLimit: sprintf (cstrName, "Battery System Remaining Time Limit"); break; + case kHIDUsage_BS_AtRate: sprintf (cstrName, "Battery System At Rate..."); break; + case kHIDUsage_BS_CapacityMode: sprintf (cstrName, "Battery System Capacity Mode"); break; + case kHIDUsage_BS_BroadcastToCharger: sprintf (cstrName, "Battery System Broadcast To Charger"); break; + case kHIDUsage_BS_PrimaryBattery: sprintf (cstrName, "Battery System Primary Battery"); break; + case kHIDUsage_BS_ChargeController: sprintf (cstrName, "Battery System Charge Controller"); break; + case kHIDUsage_BS_TerminateCharge: sprintf (cstrName, "Battery System Terminate Charge"); break; + case kHIDUsage_BS_TerminateDischarge: sprintf (cstrName, "Battery System Terminate Discharge"); break; + case kHIDUsage_BS_BelowRemainingCapacityLimit: sprintf (cstrName, "Battery System Below Remaining Capacity Limit"); break; + case kHIDUsage_BS_RemainingTimeLimitExpired: sprintf (cstrName, "Battery System Remaining Time Limit Expired"); break; + case kHIDUsage_BS_Charging: sprintf (cstrName, "Battery System Charging"); break; + case kHIDUsage_BS_Discharging: sprintf (cstrName, "Battery System Discharging"); break; + case kHIDUsage_BS_FullyCharged: sprintf (cstrName, "Battery System Fully Charged"); break; + case kHIDUsage_BS_FullyDischarged: sprintf (cstrName, "Battery System Fully Discharged"); break; + case kHIDUsage_BS_ConditioningFlag: sprintf (cstrName, "Battery System Conditioning Flag"); break; + case kHIDUsage_BS_AtRateOK: sprintf (cstrName, "Battery System At Rate OK"); break; + case kHIDUsage_BS_SMBErrorCode: sprintf (cstrName, "Battery System SMB Error Code"); break; + case kHIDUsage_BS_NeedReplacement: sprintf (cstrName, "Battery System Need Replacement"); break; + case kHIDUsage_BS_AtRateTimeToFull: sprintf (cstrName, "Battery System At Rate Time To Full"); break; + case kHIDUsage_BS_AtRateTimeToEmpty: sprintf (cstrName, "Battery System At Rate Time To Empty"); break; + case kHIDUsage_BS_AverageCurrent: sprintf (cstrName, "Battery System Average Current"); break; + case kHIDUsage_BS_Maxerror: sprintf (cstrName, "Battery System Max Error"); break; + case kHIDUsage_BS_RelativeStateOfCharge: sprintf (cstrName, "Battery System Relative State Of Charge"); break; + case kHIDUsage_BS_AbsoluteStateOfCharge: sprintf (cstrName, "Battery System Absolute State Of Charge"); break; + case kHIDUsage_BS_RemainingCapacity: sprintf (cstrName, "Battery System Remaining Capacity"); break; + case kHIDUsage_BS_FullChargeCapacity: sprintf (cstrName, "Battery System Full Charge Capacity"); break; + case kHIDUsage_BS_RunTimeToEmpty: sprintf (cstrName, "Battery System Run Time To Empty"); break; + case kHIDUsage_BS_AverageTimeToEmpty: sprintf (cstrName, "Battery System Average Time To Empty"); break; + case kHIDUsage_BS_AverageTimeToFull: sprintf (cstrName, "Battery System Average Time To Full"); break; + case kHIDUsage_BS_CycleCount: sprintf (cstrName, "Battery System Cycle Count"); break; + case kHIDUsage_BS_BattPackModelLevel: sprintf (cstrName, "Battery System Batt Pack Model Level"); break; + case kHIDUsage_BS_InternalChargeController: sprintf (cstrName, "Battery System Internal Charge Controller"); break; + case kHIDUsage_BS_PrimaryBatterySupport: sprintf (cstrName, "Battery System Primary Battery Support"); break; + case kHIDUsage_BS_DesignCapacity: sprintf (cstrName, "Battery System Design Capacity"); break; + case kHIDUsage_BS_SpecificationInfo: sprintf (cstrName, "Battery System Specification Info"); break; + case kHIDUsage_BS_ManufacturerDate: sprintf (cstrName, "Battery System Manufacturer Date"); break; + case kHIDUsage_BS_SerialNumber: sprintf (cstrName, "Battery System Serial Number"); break; + case kHIDUsage_BS_iManufacturerName: sprintf (cstrName, "Battery System Manufacturer Name Index"); break; + case kHIDUsage_BS_iDevicename: sprintf (cstrName, "Battery System Device Name Index"); break; + case kHIDUsage_BS_iDeviceChemistry: sprintf (cstrName, "Battery System Device Chemistry Index"); break; + case kHIDUsage_BS_ManufacturerData: sprintf (cstrName, "Battery System Manufacturer Data"); break; + case kHIDUsage_BS_Rechargable: sprintf (cstrName, "Battery System Rechargable"); break; + case kHIDUsage_BS_WarningCapacityLimit: sprintf (cstrName, "Battery System Warning Capacity Limit"); break; + case kHIDUsage_BS_CapacityGranularity1: sprintf (cstrName, "Battery System Capacity Granularity 1"); break; + case kHIDUsage_BS_CapacityGranularity2: sprintf (cstrName, "Battery System Capacity Granularity 2"); break; + case kHIDUsage_BS_iOEMInformation: sprintf (cstrName, "Battery System OEM Information Index"); break; + case kHIDUsage_BS_InhibitCharge: sprintf (cstrName, "Battery System Inhibit Charge"); break; + case kHIDUsage_BS_EnablePolling: sprintf (cstrName, "Battery System Enable Polling"); break; + case kHIDUsage_BS_ResetToZero: sprintf (cstrName, "Battery System Reset To Zero"); break; + case kHIDUsage_BS_ACPresent: sprintf (cstrName, "Battery System AC Present"); break; + case kHIDUsage_BS_BatteryPresent: sprintf (cstrName, "Battery System Battery Present"); break; + case kHIDUsage_BS_PowerFail: sprintf (cstrName, "Battery System Power Fail"); break; + case kHIDUsage_BS_AlarmInhibited: sprintf (cstrName, "Battery System Alarm Inhibited"); break; + case kHIDUsage_BS_ThermistorUnderRange: sprintf (cstrName, "Battery System Thermistor Under Range"); break; + case kHIDUsage_BS_ThermistorHot: sprintf (cstrName, "Battery System Thermistor Hot"); break; + case kHIDUsage_BS_ThermistorCold: sprintf (cstrName, "Battery System Thermistor Cold"); break; + case kHIDUsage_BS_ThermistorOverRange: sprintf (cstrName, "Battery System Thermistor Over Range"); break; + case kHIDUsage_BS_VoltageOutOfRange: sprintf (cstrName, "Battery System Voltage Out Of Range"); break; + case kHIDUsage_BS_CurrentOutOfRange: sprintf (cstrName, "Battery System Current Out Of Range"); break; + case kHIDUsage_BS_CurrentNotRegulated: sprintf (cstrName, "Battery System Current Not Regulated"); break; + case kHIDUsage_BS_VoltageNotRegulated: sprintf (cstrName, "Battery System Voltage Not Regulated"); break; + case kHIDUsage_BS_MasterMode: sprintf (cstrName, "Battery System Master Mode"); break; + case kHIDUsage_BS_ChargerSelectorSupport: sprintf (cstrName, "Battery System Charger Support Selector"); break; + case kHIDUsage_BS_ChargerSpec: sprintf (cstrName, "attery System Charger Specification"); break; + case kHIDUsage_BS_Level2: sprintf (cstrName, "Battery System Charger Level 2"); break; + case kHIDUsage_BS_Level3: sprintf (cstrName, "Battery System Charger Level 3"); break; + default: sprintf (cstrName, "Battery System Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_AlphanumericDisplay: + switch (element->usage) + { + default: sprintf (cstrName, "Alphanumeric Display Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_BarCodeScanner: + switch (element->usage) + { + default: sprintf (cstrName, "Bar Code Scanner Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Scale: + switch (element->usage) + { + default: sprintf (cstrName, "Scale Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_CameraControl: + switch (element->usage) + { + default: sprintf (cstrName, "Camera Control Usage 0x%lx", element->usage); break; + } + break; + case kHIDPage_Arcade: + switch (element->usage) + { + default: sprintf (cstrName, "Arcade Usage 0x%lx", element->usage); break; + } + break; + default: + if (element->usagePage > kHIDPage_VendorDefinedStart) + sprintf (cstrName, "Vendor Defined Usage 0x%lx", element->usage); + else + sprintf (cstrName, "Page: 0x%lx, Usage: 0x%lx", element->usagePage, element->usage); + break; } - return(cstrName); + return(cstrName); } #endif /* #ifdef __APPLE__ */ + diff --git a/hid_linux.c b/hid_linux.c index 05d8fa8..93b3b3b 100644 --- a/hid_linux.c +++ b/hid_linux.c @@ -348,7 +348,7 @@ void hid_ff_print( t_hid *x ) /* Pd [hid] FUNCTIONS */ /* ------------------------------------------------------------------------------ */ -t_int hid_get_events(t_hid *x) +void hid_get_events(t_hid *x) { debug_print(LOG_DEBUG,"hid_get_events"); @@ -362,7 +362,7 @@ t_int hid_get_events(t_hid *x) */ struct input_event hid_input_event; - if (x->x_fd < 0) return 0; + if (x->x_fd < 0) return; while( read (x->x_fd, &(hid_input_event), sizeof(struct input_event)) > -1 ) { @@ -398,7 +398,7 @@ t_int hid_get_events(t_hid *x) //post("output %d events",event_counter); ); - return (0); + return; } @@ -420,7 +420,7 @@ t_int hid_open_device(t_hid *x, t_int device_number) x->x_fd = -1; x->x_device_number = device_number; - sprintf(dev_handle_name,"/dev/input/event%d",(int)x->x_device_number); + sprintf(dev_handle_name,"/dev/input/event%d",x->x_device_number); if (dev_handle_name) { -- cgit v1.2.1