/* --------------------------------------------------------------------------*/ /* */ /* interface to native HID (Human Interface Devices) API */ /* Written by Hans-Christoph Steiner */ /* */ /* Copyright (c) 2004-2006 Hans-Christoph Steiner */ /* */ /* This program is free software; you can redistribute it and/or */ /* modify it under the terms of the GNU General Public License */ /* as published by the Free Software Foundation; either version 3 */ /* of the License, or (at your option) any later version. */ /* */ /* See file LICENSE for further informations on licensing terms. */ /* */ /* This program is distributed in the hope that it will be useful, */ /* but WITHOUT ANY WARRANTY; without even the implied warranty of */ /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */ /* GNU General Public License for more details. */ /* */ /* You should have received a copy of the GNU General Public License */ /* along with this program; if not, write to the Free Software Foundation, */ /* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* */ /* --------------------------------------------------------------------------*/ #include #include #include #include #include #include "hid.h" /*------------------------------------------------------------------------------ * LOCAL DEFINES */ #define DEBUG(x) //#define DEBUG(x) x unsigned short global_debug_level = 0; /* higher numbers means more messages */ static t_class *hid_class; /*------------------------------------------------------------------------------ * FUNCTION PROTOTYPES */ //static void hid_poll(t_hid *x, t_float f); static void hid_open(t_hid *x, t_symbol *s, int argc, t_atom *argv); //static t_int hid_close(t_hid *x); //static t_int hid_read(t_hid *x,int fd); //static void hid_float(t_hid* x, t_floatarg f); /*------------------------------------------------------------------------------ * GLOBAL VARIABLES DECLARED extern IN hid.h */ t_int hid_instance_count; unsigned short device_count; /* this is used to test for the first instance to execute */ double last_execute_time[MAX_DEVICES]; /* 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]; /*------------------------------------------------------------------------------ * SUPPORT FUNCTIONS */ void debug_print(t_int message_debug_level, const char *fmt, ...) { if(message_debug_level <= global_debug_level) { char buf[MAXPDSTRING]; va_list ap; //t_int arg[8]; va_start(ap, fmt); vsnprintf(buf, MAXPDSTRING-1, fmt, ap); post(buf); va_end(ap); } } void debug_error(t_hid *x, t_int message_debug_level, const char *fmt, ...) { if(message_debug_level <= global_debug_level) { char buf[MAXPDSTRING]; va_list ap; //t_int arg[8]; va_start(ap, fmt); vsnprintf(buf, MAXPDSTRING-1, fmt, ap); pd_error(x, buf); va_end(ap); } } static void output_status(t_hid *x, t_symbol *selector, t_float output_value) { t_atom *output_atom = getbytes(sizeof(t_atom)); SETFLOAT(output_atom, output_value); outlet_anything( x->x_status_outlet, selector, 1, output_atom); freebytes(output_atom,sizeof(t_atom)); } static void output_open_status(t_hid *x) { output_status(x, gensym("open"), x->x_device_open); } static void output_device_number(t_hid *x) { output_status(x, gensym("device"), x->x_device_number); } static void output_poll_time(t_hid *x) { output_status(x, gensym("poll"), x->x_delay); } static void output_device_count(t_hid *x) { output_status(x, gensym("total"), device_count); } static void output_element_ranges(t_hid *x) { if( (x->x_device_number > -1) && (x->x_device_open) ) { unsigned int i; t_atom output_data[4]; for(i=0;ix_device_number];++i) { SETSYMBOL(output_data, element[x->x_device_number][i]->type); SETSYMBOL(output_data + 1, element[x->x_device_number][i]->name); SETFLOAT(output_data + 2, element[x->x_device_number][i]->min); SETFLOAT(output_data + 3, element[x->x_device_number][i]->max); outlet_anything(x->x_status_outlet, gensym("range"), 4, output_data); } } } static unsigned int name_to_usage(char *usage_name) { // output usagepage << 16 + usage if(strcmp(usage_name,"pointer") == 0) return(0x00010001); if(strcmp(usage_name,"mouse") == 0) return(0x00010002); if(strcmp(usage_name,"joystick") == 0) return(0x00010004); if(strcmp(usage_name,"gamepad") == 0) return(0x00010005); if(strcmp(usage_name,"keyboard") == 0) return(0x00010006); if(strcmp(usage_name,"keypad") == 0) return(0x00010007); if(strcmp(usage_name,"multiaxiscontroller") == 0) return(0x00010008); return(0); } static short get_device_number_from_arguments(int argc, t_atom *argv) { short device_number = -1; unsigned short device_type_instance; unsigned int usage; unsigned short vendor_id; unsigned short product_id; char device_type_string[MAXPDSTRING] = ""; t_symbol *first_argument; t_symbol *second_argument; if(argc == 1) { first_argument = atom_getsymbolarg(0,argc,argv); if(first_argument == &s_) { // single float arg means device # 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); } else { // single symbol arg means first instance of a device type atom_string(argv, device_type_string, MAXPDSTRING-1); usage = name_to_usage(device_type_string); device_number = get_device_number_from_usage(0, usage >> 16, usage & 0xffff); debug_print(LOG_INFO,"[hid] using 0x%04x 0x%04x for %s", usage >> 16, usage & 0xffff, device_type_string); } } else if(argc == 2) { first_argument = atom_getsymbolarg(0,argc,argv); second_argument = atom_getsymbolarg(1,argc,argv); if( second_argument == &s_ ) { /* a symbol then a float means match on usage */ atom_string(argv, device_type_string, MAXPDSTRING-1); usage = name_to_usage(device_type_string); device_type_instance = atom_getfloatarg(1,argc,argv); debug_print(LOG_DEBUG,"[hid] looking for %s at #%d", device_type_string, device_type_instance); device_number = get_device_number_from_usage(device_type_instance, 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); device_number = get_device_number_by_id(vendor_id,product_id); } } return(device_number); } 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 { #if 1 // this is [hid] compatible 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); #else // this outputs instance number, for [hid] v2 t_atom event_data[3]; SETSYMBOL(event_data, output_data->name); SETFLOAT(event_data + 1, output_data->instance); SETFLOAT(event_data + 2, output_data->value); outlet_anything(x->x_data_outlet,output_data->type,3,event_data); #endif } } /* stop polling the device */ static void stop_poll(t_hid* x) { debug_print(LOG_DEBUG,"stop_poll"); if (x->x_started) { clock_unset(x->x_clock); debug_print(LOG_INFO,"[hid] polling stopped"); x->x_started = 0; } } /*------------------------------------------------------------------------------ * METHODS FOR [hid]'s MESSAGES */ void hid_poll(t_hid* x, t_float f) { debug_print(LOG_DEBUG,"hid_poll"); /* if the user sets the delay less than 2, set to block size */ if( f > 2 ) x->x_delay = (t_int)f; else if( f > 0 ) //TODO make this the actual time between message processing x->x_delay = 1.54; if(x->x_device_number > -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) { x->x_delay = (t_int)f; hid_poll(x,f); } else if(f == 1) { if(! x->x_started) hid_poll(x,f); } else if(f == 0) { stop_poll(x); } } /* close the device */ t_int hid_close(t_hid *x) { debug_print(LOG_DEBUG,"hid_close"); /* just to be safe, stop it first */ stop_poll(x); if(! hid_close_device(x)) { debug_print(LOG_INFO,"[hid] closed device %d",x->x_device_number); x->x_device_open = 0; return (0); } return (1); } /* hid_open behavoir * current state action * --------------------------------------- * closed / same device open * open / same device no action * closed / different device open * open / different device close open */ static void hid_open(t_hid *x, t_symbol *s, int argc, t_atom *argv) { debug_print(LOG_DEBUG,"hid_%s",s->s_name); /* store running state to be restored after the device has been opened */ t_int started = x->x_started; 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) ) hid_close(x); if(! x->x_device_open) { if(hid_open_device(x,device_number)) error("[hid] can not open device %d",device_number); else { x->x_device_open = 1; x->x_device_number = device_number; } } } else debug_print(LOG_WARNING,"[hid] device does not exist"); /* restore the polling state so that when I [tgl] is used to start/stop [hid], * the [tgl]'s state will continue to accurately reflect [hid]'s state */ if(started) hid_set_from_float(x,x->x_delay); debug_print(LOG_DEBUG,"[hid] set device# to %d",device_number); output_open_status(x); output_device_number(x); } t_int hid_read(t_hid *x, int fd) { // debug_print(LOG_DEBUG,"hid_read"); unsigned int i; double right_now = clock_getlogicaltime(); t_hid_element *current_element; if(right_now > last_execute_time[x->x_device_number]) { hid_get_events(x); last_execute_time[x->x_device_number] = right_now; /* post("executing: instance %d/%d at %ld", x->x_instance, hid_instance_count, right_now);*/ } for(i=0; i< element_count[x->x_device_number]; ++i) { current_element = element[x->x_device_number][i]; 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; } } if (x->x_started) { clock_delay(x->x_clock, x->x_delay); } // TODO: why is this 1? return 1; } static void hid_info(t_hid *x) { output_open_status(x); output_device_number(x); output_device_count(x); output_poll_time(x); output_element_ranges(x); hid_platform_specific_info(x); } static void hid_float(t_hid* x, t_floatarg f) { debug_print(LOG_DEBUG,"hid_float"); hid_set_from_float(x,f); } static void hid_debug(t_hid *x, t_float f) { global_debug_level = f; } /*------------------------------------------------------------------------------ * system functions */ static void hid_free(t_hid* x) { debug_print(LOG_DEBUG,"hid_free"); hid_close(x); clock_free(x->x_clock); hid_instance_count--; hid_platform_specific_free(x); } /* create a new instance of this class */ static void *hid_new(t_symbol *s, int argc, t_atom *argv) { t_hid *x = (t_hid *)pd_new(hid_class); unsigned int i; debug_print(LOG_DEBUG,"hid_%s",s->s_name); /* only display the version when the first instance is loaded */ if(!hid_instance_count) { post("[hid] %d.%d, written by Hans-Christoph Steiner ", HID_MAJOR_VERSION, HID_MINOR_VERSION); post("\tcompiled on "__DATE__" at "__TIME__ " "); } #if !defined(__linux__) && !defined(__APPLE__) error(" !! WARNING !! WARNING !! WARNING !! WARNING !! WARNING !! WARNING !!"); error(" This is a dummy, since this object only works GNU/Linux and MacOS X!"); error(" !! WARNING !! WARNING !! WARNING !! WARNING !! WARNING !! WARNING !!"); #endif /* init vars */ x->x_has_ff = 0; x->x_device_open = 0; x->x_started = 0; x->x_delay = DEFAULT_DELAY; for(i=0; ix_clock = clock_new(x, (t_method)hid_read); /* create anything outlet used for HID data */ x->x_data_outlet = outlet_new(&x->x_obj, 0); x->x_status_outlet = outlet_new(&x->x_obj, 0); x->x_device_number = get_device_number_from_arguments(argc, argv); x->x_instance = hid_instance_count; hid_instance_count++; return (x); } void hid_setup(void) { debug_print(LOG_DEBUG,"hid_setup"); hid_class = class_new(gensym("hid"), (t_newmethod)hid_new, (t_method)hid_free, sizeof(t_hid), CLASS_DEFAULT, A_GIMME,0); /* add inlet datatype methods */ class_addfloat(hid_class,(t_method) hid_float); class_addbang(hid_class,(t_method) hid_read); /* class_addanything(hid_class,(t_method) hid_anything); */ /* add inlet message methods */ class_addmethod(hid_class,(t_method) hid_debug,gensym("debug"),A_DEFFLOAT,0); class_addmethod(hid_class,(t_method) hid_build_device_list,gensym("refresh"),0); class_addmethod(hid_class,(t_method) hid_print,gensym("print"),0); class_addmethod(hid_class,(t_method) hid_info,gensym("info"),0); class_addmethod(hid_class,(t_method) hid_open,gensym("open"),A_GIMME,0); class_addmethod(hid_class,(t_method) hid_close,gensym("close"),0); class_addmethod(hid_class,(t_method) hid_poll,gensym("poll"),A_DEFFLOAT,0); /* force feedback messages */ class_addmethod(hid_class,(t_method) hid_ff_autocenter, gensym("ff_autocenter"),A_DEFFLOAT,0); class_addmethod(hid_class,(t_method) hid_ff_gain,gensym("ff_gain"),A_DEFFLOAT,0); class_addmethod(hid_class,(t_method) hid_ff_motors,gensym("ff_motors"),A_DEFFLOAT,0); class_addmethod(hid_class,(t_method) hid_ff_continue,gensym("ff_continue"),0); class_addmethod(hid_class,(t_method) hid_ff_pause,gensym("ff_pause"),0); class_addmethod(hid_class,(t_method) hid_ff_reset,gensym("ff_reset"),0); class_addmethod(hid_class,(t_method) hid_ff_stopall,gensym("ff_stopall"),0); /* ff tests */ class_addmethod(hid_class,(t_method) hid_ff_fftest,gensym("fftest"),A_DEFFLOAT,0); class_addmethod(hid_class,(t_method) hid_ff_print,gensym("ff_print"),0); }