vrpn_Nikon_Controls::vrpn_Nikon_Controls(const char *device_name, vrpn_Connection *con, const char *port_name)
: vrpn_Serial_Analog(device_name, con, port_name),
vrpn_Analog_Output(device_name, con)
{
num_channel = 1; // Focus control
o_num_channel = 1; // Focus control
// Set the mode to reset
_status = STATUS_RESETTING;
// Register to receive the message to request changes and to receive connection
// messages.
if (d_connection != NULL) {
if (register_autodeleted_handler(request_m_id, handle_request_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_Nikon_Controls: can't register handler\n");
d_connection = NULL;
}
if (register_autodeleted_handler(request_channels_m_id, handle_request_channels_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_Nikon_Controls: can't register handler\n");
d_connection = NULL;
}
if (register_autodeleted_handler(d_ping_message_id, handle_connect_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_Nikon_Controls: can't register handler\n");
d_connection = NULL;
}
} else {
fprintf(stderr,"vrpn_Nikon_Controls: Can't get connection!\n");
}
}
vrpn_XInputGamepad::vrpn_XInputGamepad(const char *name, vrpn_Connection *c, unsigned int controllerIndex):
vrpn_Analog(name, c),
vrpn_Button(name, c),
vrpn_Analog_Output(name, c),
_controllerIndex(controllerIndex)
{
vrpn_Analog::num_channel = 7;
vrpn_Button::num_buttons = 10;
vrpn_Analog_Output::o_num_channel = 2;
_motorSpeed[0] = 0;
_motorSpeed[1] = 0;
if (register_autodeleted_handler(request_m_id,
handle_request_message, this, d_sender_id)) {
fprintf(stderr, "vrpn_XInputGamepad: Can't register request-single handler\n");
return;
}
if (register_autodeleted_handler(request_channels_m_id,
handle_request_channels_message, this, d_sender_id)) {
fprintf(stderr, "vrpn_XInputGamepad: Can't register request-multiple handler\n");
return;
}
if (register_autodeleted_handler(
d_connection->register_message_type(vrpn_dropped_last_connection),
handle_last_connection_dropped, this)) {
fprintf(stderr, "vrpn_XInputGamepad: Can't register connections-dropped handler\n");
return;
}
}
vrpn_Button_Filter::vrpn_Button_Filter(const char *name, vrpn_Connection *c)
: vrpn_Button(name, c)
{
if ((d_sender_id == -1) || (admin_message_id == -1)) {
fprintf(stderr, "vrpn_Button: Can't register IDs\n");
d_connection = NULL;
}
register_autodeleted_handler(admin_message_id, client_msg_handler, this);
// setup message id type for alert messages to alert a device about changes
alert_message_id = d_connection->register_message_type("vrpn_Button Alert");
send_alerts = 0; // used to turn on/off alerts -- send and admin message
// from
// remote to turn it on -- or server side call set_alerts();
// Set up callback handler for ping message from client so that it
// sends the button states. This will make sure that the other side hears
// the initial button states. Also set this up
// to fire on the "new connection" system message.
register_autodeleted_handler(d_ping_message_id, handle_ping_message, this,
d_sender_id);
register_autodeleted_handler(
d_connection->register_message_type(vrpn_got_connection),
handle_ping_message, this, vrpn_ANY_SENDER);
// set button default buttonstates
for (vrpn_int32 i = 0; i < vrpn_BUTTON_MAX_BUTTONS; i++) {
buttonstate[i] = vrpn_BUTTON_MOMENTARY;
}
return;
}
vrpn_Analog_Output_Server::vrpn_Analog_Output_Server(const char* name, vrpn_Connection * c,
vrpn_int32 numChannels) :
vrpn_Analog_Output(name, c)
{
this->setNumChannels( numChannels );
// Check if we have a connection
if (d_connection == NULL) {
fprintf(stderr, "vrpn_Analog_Output: Can't get connection!\n");
}
// Register a handler for the request channel change message
if (register_autodeleted_handler(request_m_id,
handle_request_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Analog_Output_Server: can't register change channel request handler\n");
d_connection = NULL;
}
// Register a handler for the request channels change message
if (register_autodeleted_handler(request_channels_m_id,
handle_request_channels_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Analog_Output_Server: can't register change channels request handler\n");
d_connection = NULL;
}
// Register a handler for vrpn_got_connection, so we can tell the
// client how many channels are active
if( register_autodeleted_handler( got_connection_m_id, handle_got_connection, this ) ) {
fprintf( stderr, "vrpn_Analog_Output_Server: can't register new connection handler\n");
d_connection = NULL;
}
}
vrpn_SGIBox::vrpn_SGIBox(char * name, vrpn_Connection * c):
vrpn_Analog(name, c), vrpn_Button_Filter(name, c) {
int ret;
char hn[128];
sid = -1;
winid = -1;
if (winid != -1) {
printf("Closing previous windows Winid=%d, sid = %d:\n",winid, sid);
winclose(winid);
//dglclose(sid);
dglclose(-1); // close all dgl connection;
}
ret = gethostname(hn, 100);
if (ret < 0) {
fprintf(stderr, "vrpn_SGIBox: error in gethostname()\n");
return;
}
sid = ret = dglopen(hn,DGLLOCAL);
if (ret < 0) {
fprintf(stderr, "vrpn_SGIBox: error in dglopen()\n");
return;
}
noport();
winid = winopen("");
reset();
num_channel = NUM_DIALS;
num_buttons = NUM_BUTTONS;
register_autodeleted_handler(c->register_message_type( vrpn_got_first_connection), sgibox_con_cb, this);
register_autodeleted_handler(alert_message_id,sgibox_alert_handler, this);
set_alerts(1); //turn on alerts from toggle filter class to notify
//local sgibox that lights should be turned on/off
}
void vrpn_BaseClassUnique::client_mainloop(void)
{
struct timeval now;
struct timeval diff;
// The first time through, set up a callback handler for the pong message so that we
// know when we are getting them. Also set up a handler for the system dropped-connection
// message so that we can initiate a ping cycle when that happens. Also, we'll initiate
// the ping cycle here.
if (d_first_mainloop && (d_connection != NULL)) {
// Set up handlers for the pong message and for the system connection-drop message
register_autodeleted_handler(d_pong_message_id, handle_pong, this, d_sender_id);
register_autodeleted_handler(d_connection->register_message_type(vrpn_dropped_connection),
handle_connection_dropped, this);
// Initiate a ping cycle;
initiate_ping_cycle();
// No longer first time through mainloop.
d_first_mainloop = 0;
}
// If we are in the middle of a ping cycle...
// Check if we've heard, if it has been long enough since we gave a warning or error (>= 1 sec).
// If it has been three seconds or more since we sent our first ping,
// start giving warnings. If it has been ten seconds or more since we got one,
// switch to errors. New ping requests go out each second.
if (d_unanswered_ping) {
vrpn_gettimeofday(&now, NULL);
diff = vrpn_TimevalDiff(now, d_time_last_warned);
vrpn_TimevalNormalize(diff);
if (diff.tv_sec >= 1) {
// Send a new ping, since it has been a second since the last one
d_connection->pack_message(0, now, d_ping_message_id, d_sender_id,
NULL, vrpn_CONNECTION_RELIABLE);
// Send another warning or error, and say if we're flatlined (10+ seconds)
d_time_last_warned = now;
if (!shutup) {
diff = vrpn_TimevalDiff(now, d_time_first_ping);
vrpn_TimevalNormalize(diff);
if (diff.tv_sec >= 10) {
send_text_message("No response from server for >= 10 seconds", now, vrpn_TEXT_ERROR, diff.tv_sec);
d_flatline = 1;
} else if (diff.tv_sec >= 3) {
send_text_message("No response from server for >= 3 seconds", now, vrpn_TEXT_WARNING, diff.tv_sec);
}
}
}
}
}
void vrpn_Xkeys::init_hid() {
// Get notifications when clients connect and disconnect
register_autodeleted_handler(d_connection->register_message_type(vrpn_dropped_last_connection), on_last_disconnect, this);
register_autodeleted_handler(d_connection->register_message_type(vrpn_got_connection), on_connect, this);
// Indicate we're waiting for a connection by turning on the red LED
vrpn_uint8 outputs[9] = {0};
outputs[8] = 128;
send_data(9, outputs);
}
vrpn_RedundantController::vrpn_RedundantController(
vrpn_RedundantTransmission *r, vrpn_Connection *c)
: vrpn_BaseClass("vrpn Redundant Transmission Controller", c)
, d_object(r)
{
vrpn_BaseClass::init();
// fprintf(stderr, "Registering set handler with type %d.\n",
// d_protocol.d_set_type);
register_autodeleted_handler(d_protocol.d_set_type, handle_set, this);
register_autodeleted_handler(d_protocol.d_enable_type, handle_enable, this);
}
vrpn_OmegaTemperature::vrpn_OmegaTemperature (const char * name, vrpn_Connection * c,
const char * port, float temp1, float temp2, bool control_on):
vrpn_Serial_Analog(name, c, port, 115200, 8, vrpn_SER_PARITY_NONE, true),
vrpn_Analog_Output(name, c),
vrpn_Button_Filter(name, c)
{
// XXX Make this configurable?
int baud = 38400;
char parity = 'n'; // XXX What should this be?
int stop_bits = 1;
d_modbus = modbus_new_rtu(port, baud, parity, 8, stop_bits);
// XXX No code below has been changed yet.
num_channel = 6;
o_num_channel = 3;
num_buttons = 1;
buttons[0] = control_on;
// Fill in the arguments to send to the device at reset time.
o_channel[0] = temp1;
o_channel[1] = temp2;
o_channel[2] = control_on;
// Set the mode to reset
status = STATUS_RESETTING;
// Register to receive the message to request changes and to receive connection
// messages.
if (d_connection != NULL) {
if (register_autodeleted_handler(request_m_id, handle_request_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_OmegaTemperature: can't register handler\n");
d_connection = NULL;
}
if (register_autodeleted_handler(request_channels_m_id, handle_request_channels_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_OmegaTemperature: can't register handler\n");
d_connection = NULL;
}
if (register_autodeleted_handler(d_ping_message_id, handle_connect_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_OmegaTemperature: can't register handler\n");
d_connection = NULL;
}
} else {
fprintf(stderr,"vrpn_OmegaTemperature: Can't get connection!\n");
}
}
vrpn_Analog_Remote::vrpn_Analog_Remote (const char * name,
vrpn_Connection * c ) :
vrpn_Analog (name, c)
{
vrpn_int32 i;
// Register a handler for the change callback from this device,
// if we got a connection.
if (d_connection != NULL) {
if (register_autodeleted_handler(channel_m_id, handle_change_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_Analog_Remote: can't register handler\n");
d_connection = NULL;
}
} else {
fprintf(stderr,"vrpn_Analog_Remote: Can't get connection!\n");
}
// At the start, as far as the client knows, the device could have
// max channels -- the number of channels is specified in each
// message.
num_channel=vrpn_CHANNEL_MAX;
for (i = 0; i < vrpn_CHANNEL_MAX; i++) {
channel[i] = last[i] = 0;
}
vrpn_gettimeofday(×tamp, NULL);
}
VRPN_AciCommand_transport_remote::VRPN_AciCommand_transport_remote(
const char *name, vrpn_Connection *c)
: VRPN_AciCommand_transport_base(name, c)
{
// Register a handler for the image-response message.
register_autodeleted_handler(d_command_response_m_id, handle_response_message, this, d_sender_id);
}
VRPN_AciCommand_transport_server::VRPN_AciCommand_transport_server(
const char *name, vrpn_Connection *c)
: VRPN_AciCommand_transport_base(name, c)
{
// Register a handler for the command message.
register_autodeleted_handler(d_command_send_m_id, handle_command_message, this, d_sender_id);
}
vrpn_Text_Receiver::vrpn_Text_Receiver (const char * name,
vrpn_Connection * c) :
vrpn_BaseClass(name, c)
{
init();
if (d_connection) {
register_autodeleted_handler(d_text_message_id, handle_message, this, d_sender_id);
}
};
void vrpn_BaseClassUnique::server_mainloop(void)
{
// Set up to handle pong message. This should be sent whenever there is
// a ping request from a client.
if (d_first_mainloop && (d_connection != NULL)) {
register_autodeleted_handler(d_ping_message_id, handle_ping, this, d_sender_id);
d_first_mainloop = 0;
}
}
vrpn_Tracker_PhaseSpace::vrpn_Tracker_PhaseSpace(const char *name, vrpn_Connection *c, const char* device, float frequency,int readflag, int slave)
: vrpn_Tracker(name,c)
{
#ifdef DEBUG
printf("%s %s %s %f %d\n", __PRETTY_FUNCTION__, name, device, frequency, readflag);
#endif
if(d_connection) {
// Register a handler for the update change callback
if (register_autodeleted_handler(update_rate_id, handle_update_rate_request, this, d_sender_id))
fprintf(stderr,"vrpn_Tracker: Can't register workspace handler\n");
}
this->slave = slave;
this->frequency = frequency;
numRigids = 0;
numMarkers = 0;
markers.reserve(VRPN_PHASESPACE_MAXMARKERS);
rigids.reserve(VRPN_PHASESPACE_MAXRIGIDS);
int owlflag = 0;
if(slave) owlflag |= OWL_SLAVE;
int ret = owlInit(device,owlflag);
if(ret != owlflag) {
fprintf(stderr, "owlInit error: 0x%x\n", ret);
owlRunning = false;
return;
} else {
owlRunning = true;
}
char msg[512];
if(owlGetString(OWL_VERSION,msg)) {
printf("OWL version: %s\n",msg);
} else {
printf("Unable to query OWL version.\n");
}
if(!slave) {
//The master point tracker is index 0. So all rigid trackers will start from 1.
owlTrackeri(0, OWL_CREATE, OWL_POINT_TRACKER);
if(!owlGetStatus()) {
fprintf(stderr,"Error: Unable to create main point tracker.\n");
return;
}
} else {
printf("Ignoring tracker creation in slave mode.\n");
}
readMostRecent = readflag ? true : false;
frame = 0;
}
vrpn_BiosciencesTools::vrpn_BiosciencesTools (const char * name, vrpn_Connection * c,
const char * port, float temp1, float temp2, bool control_on):
vrpn_Serial_Analog(name, c, port, 115200),
vrpn_Analog_Output(name, c),
vrpn_Button_Filter(name, c)
{
num_channel = 6;
o_num_channel = 3;
num_buttons = 1;
// Fill in the arguments to send to the device at reset time.
o_channel[0] = temp1;
o_channel[1] = temp2;
o_channel[2] = control_on;
// Set the mode to reset
status = STATUS_RESETTING;
// Register to receive the message to request changes and to receive connection
// messages.
if (d_connection != NULL) {
if (register_autodeleted_handler(request_m_id, handle_request_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_BiosciencesTools: can't register handler\n");
d_connection = NULL;
}
if (register_autodeleted_handler(request_channels_m_id, handle_request_channels_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_BiosciencesTools: can't register handler\n");
d_connection = NULL;
}
if (register_autodeleted_handler(d_ping_message_id, handle_connect_message,
this, d_sender_id)) {
fprintf(stderr,"vrpn_BiosciencesTools: can't register handler\n");
d_connection = NULL;
}
} else {
fprintf(stderr,"vrpn_BiosciencesTools: Can't get connection!\n");
}
}
vrpn_Poser_Server::vrpn_Poser_Server (const char* name, vrpn_Connection * c) :
vrpn_Poser(name, c)
{
// register_server_handlers();
// Make sure that we have a valid connection
if (d_connection == NULL) {
fprintf(stderr,"vrpn_Poser_Server: No connection\n");
return;
}
// Register a handler for the position change callback for this device
if (register_autodeleted_handler(req_position_m_id,
handle_change_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Poser_Server: can't register position handler\n");
d_connection = NULL;
}
// Register a handler for the relative position change callback for this device
if (register_autodeleted_handler(req_position_relative_m_id,
handle_relative_change_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Poser_Server: can't register relative position handler\n");
d_connection = NULL;
}
// Register a handler for the velocity change callback for this device
if (register_autodeleted_handler(req_velocity_m_id,
handle_vel_change_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Poser_Server: can't register velocity handler\n");
d_connection = NULL;
}
// Register a handler for the relative velocity change callback for this device
if (register_autodeleted_handler(req_velocity_relative_m_id,
handle_relative_vel_change_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Poser_Server: can't register velocity handler\n");
d_connection = NULL;
}
}
/// custom contructor for falcon device tracker. handles a single device.
vrpn_Tracker_NovintFalcon::vrpn_Tracker_NovintFalcon(const char *name,
vrpn_Connection *c,
const int devidx,
const char *grip,
const char *kine,
const char *damp)
: vrpn_Tracker(name, c), vrpn_Button_Filter(name, c),
vrpn_ForceDevice(name, c), m_dev(NULL), m_obj(NULL), m_update_rate(1000.0), m_damp(0.9)
{
m_devflags=vrpn_NovintFalcon_Device::MASK_DEVICEIDX & devidx;
if (grip != NULL) {
if (0 == strcmp(grip,"4-button")) {
m_devflags |= vrpn_NovintFalcon_Device::GRIP_FOURBUTTON;
vrpn_Button::num_buttons = 4;
} else {
fprintf(stderr, "WARNING: Unknown grip for Novint Falcon #%d: %s \n", devidx, grip);
m_devflags = -1;
return;
}
}
if (kine != NULL) {
if (0 == strcmp(kine,"stamper")) {
m_devflags |= vrpn_NovintFalcon_Device::KINE_STAMPER;
} else {
fprintf(stderr, "WARNING: Unknown kinematic model for Novint Falcon #%d: %s \n", devidx, kine);
m_devflags = -1;
return;
}
}
if (damp != NULL) {
vrpn_float64 val= atof(damp);
if (val >= 1.0 && val <= 10000.0) {
m_damp = 1.0 - 1.0/val;
} else {
fprintf(stderr, "WARNING: Ignoring illegal force effect damping factor: %g \n", val);
}
}
clear_values();
if (register_autodeleted_handler(forcefield_message_id,
handle_forcefield_change_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Tracker_NovintFalcon:can't register force handler\n");
return;
}
vrpn_gettimeofday(&m_timestamp, NULL);
status = vrpn_TRACKER_RESETTING;
}
vrpn_Analog_Output_Callback_Server::vrpn_Analog_Output_Callback_Server(const char* name, vrpn_Connection * c,
vrpn_int32 numChannels) :
vrpn_Analog_Output_Server(name, c, numChannels)
{
// Register a handler for the request channel change message. This will go
// in the list AFTER the one for the base class, so the values will already
// have been filled in. So we just need to call the user-level callbacks
// and pass them a pointer to the data values.
if (register_autodeleted_handler(request_m_id,
handle_change_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Analog_Output_Callback_Server: can't register change channel request handler\n");
d_connection = NULL;
}
// Register a handler for the request channels change message. This will go
// in the list AFTER the one for the base class, so the values will already
// have been filled in. So we just need to call the user-level callbacks
// and pass them a pointer to the data values.
if (register_autodeleted_handler(request_channels_m_id,
handle_change_message, this, d_sender_id)) {
fprintf(stderr,"vrpn_Analog_Output_Callback_Server: can't register change channels request handler\n");
d_connection = NULL;
}
}
vrpn_Tracker_WiimoteHead::vrpn_Tracker_WiimoteHead(const char* name,
vrpn_Connection* trackercon,
const char* wiimote,
float update_rate,
float led_spacing) :
vrpn_Tracker(name, trackercon),
d_name(wiimote),
d_update_interval(update_rate ? (1.0 / update_rate) : 1.0 / 60.0),
d_blobDistance(led_spacing),
d_flipState(FLIP_UNKNOWN),
d_points(0),
d_ana(NULL),
d_contact(false),
d_lock(false),
d_updated(false),
d_gravDirty(true) {
// If the name is NULL, we're done.
if (wiimote == NULL) {
d_name = NULL;
fprintf(stderr, "vrpn_Tracker_WiimoteHead: "
"Can't start without a valid specified Wiimote device!");
return;
}
setup_wiimote();
//--------------------------------------------------------------------
// Whenever we get a connection, set a flag so we make sure to send an
// update. Set up a handler to do this.
register_autodeleted_handler(d_connection->register_message_type(vrpn_got_connection),
handle_connection, this);
//--------------------------------------------------------------------
// Set the current matrix to identity, the current timestamp to "now",
// the current matrix to identity in case we never hear from the Wiimote.
// Also, set the updated flag to send a single report
reset();
// put a little z translation as a saner default
d_currentPose.xyz[2] = 1;
// Set up our initial "default" pose to make sure everything is
// safely initialized before our first report.
_convert_pose_to_tracker();
}
vrpn_Analog_Output_Remote::vrpn_Analog_Output_Remote(const char* name, vrpn_Connection * c) :
vrpn_Analog_Output(name, c)
{
vrpn_int32 i;
o_num_channel = vrpn_CHANNEL_MAX;
for (i = 0; i < vrpn_CHANNEL_MAX; i++) {
o_channel[i] = 0;
}
vrpn_gettimeofday(&o_timestamp, NULL);
// Register a handler for the report number of active channels message
if (register_autodeleted_handler(report_num_channels_m_id,
handle_report_num_channels, this, d_sender_id))
{
fprintf(stderr,"vrpn_Analog_Output_Remote: can't register active channel report handler\n");
d_connection = NULL;
}
}
vrpn_Button_Filter::vrpn_Button_Filter(const char *name, vrpn_Connection *c)
:vrpn_Button(name, c)
{
if ( (d_sender_id == -1) || (admin_message_id == -1) ) {
fprintf(stderr,"vrpn_Button: Can't register IDs\n");
d_connection = NULL;
}
register_autodeleted_handler(admin_message_id, client_msg_handler, this);
//setup message id type for alert messages to alert a device about changes
alert_message_id = d_connection->register_message_type("vrpn_Button Alert");
send_alerts=0; //used to turn on/off alerts -- send and admin message from
//remote to turn it on -- or server side call set_alerts();
//set button default buttonstates
for (vrpn_int32 i=0; i< vrpn_BUTTON_MAX_BUTTONS; i++) {
buttonstate[i] = vrpn_BUTTON_MOMENTARY;
}
return;
}
// ctor
vrpn_Tracker_PhaseSpace::vrpn_Tracker_PhaseSpace(const char *name, vrpn_Connection *c)
: vrpn_Tracker(name ,c),
vrpn_Button_Filter(name, c),
vrpn_Clipping_Analog_Server(name, c),
debug(false),
drop_frames(false),
smgr(NULL)
{
// TODO fix
//num_buttons = vrpn_BUTTON_MAX_BUTTONS;
num_buttons = 0;
smgr = new SensorManager();
if(d_connection) {
// Register a handler for the update change callback
if (register_autodeleted_handler(update_rate_id, handle_update_rate_request, this, d_sender_id))
fprintf(stderr,"vrpn_Tracker: Can't register workspace handler\n");
}
}
// This creates a vrpn_GlobalHapticsOrb and sets it to reset mode. It opens
// the serial device using the code in the vrpn_Serial_Analog constructor.
vrpn_GlobalHapticsOrb::vrpn_GlobalHapticsOrb(const char * name, vrpn_Connection * c,
const char * port, int baud) :
vrpn_Serial_Analog(name, c, port, baud),
vrpn_Button_Filter(name, c),
vrpn_Dial(name, c)
{
// Set the parameters in the parent classes
vrpn_Button::num_buttons = 30;
vrpn_Analog::num_channel = 3;
vrpn_Dial::num_dials = 3;
// Set the status of the buttons, analogs and encoders to 0 to start
clear_values();
// Set a callback handler for when the first connection is made so
// that it can reset the analogs and buttons whenever this happens.
register_autodeleted_handler(
d_connection->register_message_type(vrpn_got_first_connection),
handle_firstConnection, this);
// Set the mode to reset
d_status = STATUS_RESETTING;
}
void vrpn_Logitech_Controller_Raw::init_hid()
{
// Get notifications when clients connect and disconnect
register_autodeleted_handler(d_connection->register_message_type(vrpn_dropped_last_connection), on_last_disconnect, this);
register_autodeleted_handler(d_connection->register_message_type(vrpn_got_connection), on_connect, this);
}
void vrpn_Griffin::init_hid(void) {
// Get notifications when clients connect and disconnect
register_autodeleted_handler(d_connection->register_message_type(vrpn_dropped_last_connection), on_last_disconnect, this);
register_autodeleted_handler(d_connection->register_message_type(vrpn_got_connection), on_connect, this);
}
vrpn_Imager_Stream_Buffer::vrpn_Imager_Stream_Buffer(
const char *name, const char *imager_server_name, vrpn_Connection *c)
: vrpn_Auxiliary_Logger_Server(name, c)
, vrpn_Imager_Server(
name, c, 0, 0) // Default number of rows and columns for the device.
, d_logging_thread(NULL)
, d_imager_server_name(NULL)
{
// Copy the name of the server we are to connect to when we are logging.
try { d_imager_server_name = new char[strlen(imager_server_name) + 1]; }
catch (...) {
fprintf(stderr, "vrpn_Imager_Stream_Buffer::vrpn_Imager_Stream_Buffer: "
"Out of memory\n");
d_connection = NULL;
return;
}
strcpy(d_imager_server_name, imager_server_name);
// Create the logging thread but do not run it yet.
vrpn_ThreadData td;
td.pvUD = this;
try { d_logging_thread = new vrpn_Thread(static_logging_thread_func, td); }
catch (...) {
fprintf(stderr, "vrpn_Imager_Stream_Buffer::vrpn_Imager_Stream_Buffer: "
"can't create logging thread\n");
d_connection = NULL;
return;
}
// Register a handler for the got first connection message.
got_first_connection_m_id =
d_connection->register_message_type(vrpn_got_first_connection);
if (got_first_connection_m_id == -1) {
fprintf(stderr, "vrpn_Imager_Stream_Buffer::vrpn_Imager_Stream_Buffer: "
"can't register got first connection type\n");
d_connection = NULL;
return;
}
if (register_autodeleted_handler(got_first_connection_m_id,
static_handle_got_first_connection, this,
vrpn_ANY_SENDER)) {
fprintf(stderr, "vrpn_Imager_Stream_Buffer::vrpn_Imager_Stream_Buffer: "
"can't register got first connection handler\n");
d_connection = NULL;
}
// The base server class implements throttling for us, so we could just go
// ahead
// and try to send the messages all the time using the normal frame
// begin/end and
// region routines. If we do this, though, we're going to have to unpack
// and repack
// all of the messages. If we re-implement the throttling code, then we can
// just
// watch the packets as they go by and see what types they are, discarding
// as
// appropriate (but we still have to queue and watch them).
// If we implement the throttling
// code down in the thread that listens to the server, we can avoid putting
// them into the queue at all. In that case, there can be a frame or more
// in
// the queue that would drain even after the throttle message was received.
// We can subtract the number of frames in the buffer from the request if
// the
// request is large enough, thus removing the problem, but it won't work for
// the common case of requesting 0 or 1 frames. This will work in the
// steady
// state, where a sender requests one more each time it gets one, but there
// will be an initial bolus of images.
// Nonetheless, this seems like the cleanest solution. So, we will
// install
// a handler for the throttling message that will pass it on down to the
// thread
// that is baby-sitting the server object.
if (register_autodeleted_handler(d_throttle_frames_m_id,
static_handle_throttle_message, this,
vrpn_ANY_SENDER)) {
fprintf(stderr, "vrpn_Imager_Stream_Buffer::vrpn_Imager_Stream_Buffer: "
"can't register throttle handler\n");
d_connection = NULL;
}
}
vrpn_Tracker_ButtonFly::vrpn_Tracker_ButtonFly
(const char * name, vrpn_Connection * trackercon,
vrpn_Tracker_ButtonFlyParam * params, float update_rate,
bool reportChanges) :
vrpn_Tracker (name, trackercon),
d_vel_scale(NULL),
d_vel_scale_value(1.0),
d_rot_scale(NULL),
d_rot_scale_value(1.0),
d_update_interval (update_rate ? (1/update_rate) : 1.0),
d_reportChanges (reportChanges)
{
int i;
//--------------------------------------------------------------------
// Copy the parameter values and initialize the values and pointers
// in the list of axes. The setup_channel() call opens the button
// remote and sets up a callback to handle the changes.
d_num_axes = params->num_axes;
for (i = 0; i < params->num_axes; i++) {
d_axes[i].axis = params->axes[i];
d_axes[i].active = false;
d_axes[i].bf = this;
setup_channel(&d_axes[i]);
}
//--------------------------------------------------------------------
// Open the scale analogs if they have non-NULL names.
// If the name starts with the "*" character, use tracker
// connection rather than getting a new connection for it.
// Set up a callback for each to set the scale factor.
if (params->vel_scale_name != NULL) {
// Copy the parameters into our member variables
d_vel_scale_channel = params->vel_scale_channel;
d_vel_scale_offset = params->vel_scale_offset;
d_vel_scale_scale = params->vel_scale_scale;
d_vel_scale_power = params->vel_scale_power;
// Open the analog device and point the remote at it.
// If the name starts with the '*' character, use
// the server connection rather than making a new one.
if (params->vel_scale_name[0] == '*') {
d_vel_scale = new vrpn_Analog_Remote
(&(params->vel_scale_name[1]), d_connection);
} else {
d_vel_scale = new vrpn_Analog_Remote(params->vel_scale_name);
}
// Set up the callback handler
if (d_vel_scale == NULL) {
fprintf(stderr,"vrpn_Tracker_ButtonFly: "
"Can't open Analog %s\n",params->vel_scale_name);
} else {
// Set up the callback handler for the channel
d_vel_scale->register_change_handler(this, handle_velocity_update);
}
}
if (params->rot_scale_name != NULL) {
// Copy the parameters into our member variables
d_rot_scale_channel = params->rot_scale_channel;
d_rot_scale_offset = params->rot_scale_offset;
d_rot_scale_scale = params->rot_scale_scale;
d_rot_scale_power = params->rot_scale_power;
// Open the analog device and point the remote at it.
// If the name starts with the '*' character, use
// the server connection rather than making a new one.
if (params->rot_scale_name[0] == '*') {
d_rot_scale = new vrpn_Analog_Remote
(&(params->rot_scale_name[1]), d_connection);
} else {
d_rot_scale = new vrpn_Analog_Remote(params->rot_scale_name);
}
// Set up the callback handler
if (d_rot_scale == NULL) {
fprintf(stderr,"vrpn_Tracker_ButtonFly: "
"Can't open Analog %s\n",params->rot_scale_name);
} else {
// Set up the callback handler for the channel
d_rot_scale->register_change_handler(this, handle_rotation_update);
}
}
//--------------------------------------------------------------------
// Whenever we get the first connection to this server, we also
// want to reset the matrix to identity, so that you start at the
// beginning. Set up a handler to do this.
register_autodeleted_handler(d_connection->register_message_type
(vrpn_got_first_connection),
handle_newConnection, this);
//--------------------------------------------------------------------
// Set the initialization matrix to identity, then also set
// the current matrix to identity.
for ( i =0; i< 4; i++)
for (int j=0; j< 4; j++)
d_initMatrix[i][j] = 0;
d_initMatrix[0][0] = d_initMatrix[1][1] = d_initMatrix[2][2] =
d_initMatrix[3][3] = 1.0;
reset();
}
vrpn_ForceDeviceServer::vrpn_ForceDeviceServer(const char * name, vrpn_Connection *c):vrpn_ForceDevice(name,c)
{
if (register_autodeleted_handler(addObject_message_id,
handle_addObject_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(addObjectExScene_message_id,
handle_addObjectExScene_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setVertex_message_id,
handle_setVertex_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setNormal_message_id,
handle_setNormal_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setTriangle_message_id,
handle_setTriangle_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(removeTriangle_message_id,
handle_removeTriangle_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(updateTrimeshChanges_message_id,
handle_updateTrimeshChanges_message, this, vrpn_ForceDevice:: d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(transformTrimesh_message_id,
handle_transformTrimesh_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setTrimeshType_message_id,
handle_setTrimeshType_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setObjectPosition_message_id,
handle_setObjectPosition_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setObjectOrientation_message_id,
handle_setObjectOrientation_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setObjectScale_message_id,
handle_setObjectScale_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(removeObject_message_id,
handle_removeObject_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(moveToParent_message_id,
handle_moveToParent_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setHapticOrigin_message_id,
handle_setHapticOrigin_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setHapticScale_message_id,
handle_setHapticScale_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setSceneOrigin_message_id,
handle_setSceneOrigin_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(setObjectIsTouchable_message_id,
handle_setObjectIsTouchable_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
if (register_autodeleted_handler(clearTrimesh_message_id,
handle_clearTrimesh_message, this, vrpn_ForceDevice::d_sender_id)) {
fprintf(stderr,"vrpn_Phantom:can't register handler\n");
vrpn_ForceDevice::d_connection = NULL;
}
}
// Device constructor.
// Parameters:
// - name: VRPN name to assign to this server
// - c: VRPN connection this device should be attached to
vrpn_WiiMote::vrpn_WiiMote(const char *name, vrpn_Connection *c, unsigned which):
vrpn_Analog(name, c),
vrpn_Button(name, c),
vrpn_Analog_Output(name, c),
wiimote(new vrpn_Wiimote_Device)
{
int i;
char msg[1024];
vrpn_Analog::num_channel = min(64, vrpn_CHANNEL_MAX);
for (i = 0; i < vrpn_Analog::num_channel; i++) {
channel[i] = 0;
}
// There are bits for up to 16 buttons on the main remote, and for
// up to 16 more on an expansion pack.
vrpn_Button::num_buttons = min(64, vrpn_BUTTON_MAX_BUTTONS);
for (i = 0; i < vrpn_Button::num_buttons; i++) {
buttons[i] = 0;
}
vrpn_Analog_Output::o_num_channel = 1;
// Register a handler for the request channel change message
if (register_autodeleted_handler(request_m_id,
handle_request_message, this, d_sender_id)) {
FAIL("vrpn_WiiMote: can't register change channel request handler");
return;
}
// Register a handler for the request channels change message
if (register_autodeleted_handler(request_channels_m_id,
handle_request_channels_message, this, d_sender_id)) {
FAIL("vrpn_WiiMote: can't register change channels request handler");
return;
}
// Register a handler for the no-one's-connected-now message
if (register_autodeleted_handler(
d_connection->register_message_type(vrpn_dropped_last_connection),
handle_last_connection_dropped, this)) {
FAIL("Can't register self-destruct handler");
return;
}
// Get a list of available devices and select the one we want.
// Look for up to 4 motes. Timeout in 5 seconds if one not found.
wiimote->which = which;
wiimote_t **available_wiimotes = wiiuse_init(4);
unsigned num_available = wiiuse_find(available_wiimotes, 4, 5);
if (num_available < (wiimote->which + 1)) {
struct timeval now;
vrpn_gettimeofday(&now, NULL);
sprintf(msg, "Could not open remote %d (%d found)", wiimote->which, num_available);
send_text_message(msg, now, vrpn_TEXT_ERROR);
wiimote->found = false;
} else {
wiimote->found = true;
// Make a list containing just the one we want, and then connect to it.
wiimote_t *selected_one[1];
wiimote->device = selected_one[0] = available_wiimotes[wiimote->which];
wiimote->connected = (wiiuse_connect(selected_one, 1) == 1);
if (!wiimote->connected) {
struct timeval now;
vrpn_gettimeofday(&now, NULL);
sprintf(msg, "Could not connect to remote %d", wiimote->which);
send_text_message(msg, now, vrpn_TEXT_ERROR);
}
}
if (wiimote->connected) {
initialize_wiimote_state();
}
}
