void vrpn_Tracker_ButtonFly::mainloop()
{
int i;
struct timeval now;
double interval; // How long since the last report, in secs
// Call generic server mainloop, since we are a server
server_mainloop();
// Mainloop() all of the buttons that are defined and the analog
// scale values if they are defined so that we will get all of
// the values fresh.
for (i = 0; i < d_num_axes; i++) {
d_axes[i].btn->mainloop();
}
if (d_vel_scale != NULL) { d_vel_scale->mainloop(); };
if (d_rot_scale != NULL) { d_rot_scale->mainloop(); };
// See if it has been long enough since our last report.
// If so, generate a new one.
vrpn_gettimeofday(&now, NULL);
interval = duration(now, d_prevtime);
if (shouldReport(interval)) {
// Figure out the new matrix based on the current values and
// the length of the interval since the last report
update_matrix_based_on_values(interval);
d_prevtime = now;
// Set the time on the report to now.
vrpn_Tracker::timestamp = now;
// pack and deliver tracker report;
if (d_connection) {
char msgbuf[1000];
int len = encode_to(msgbuf);
if (d_connection->pack_message(len, vrpn_Tracker::timestamp,
position_m_id, d_sender_id, msgbuf,
vrpn_CONNECTION_LOW_LATENCY)) {
fprintf(stderr,"Tracker ButtonFly: cannot write message: tossing\n");
}
} else {
fprintf(stderr,"Tracker ButtonFly: No valid connection\n");
}
// We're not always sending reports, but we still want to
// update the matrix so that we don't integrate over
// too long a timespan when we do finally report a change.
} else if (interval >= d_update_interval) {
// Figure out the new matrix based on the current values and
// the length of the interval since the last report
update_matrix_based_on_values(interval);
d_prevtime = now;
}
}
void vrpn_IMU_SimpleCombiner::mainloop()
{
// Call generic server mainloop, since we are a server
server_mainloop();
// Mainloop() all of the analogs that are defined and the button
// so that we will get all of the values fresh.
if (d_acceleration.ana != NULL) { d_acceleration.ana->mainloop(); }
if (d_rotational_vel.ana != NULL) { d_rotational_vel.ana->mainloop(); }
if (d_magnetometer.ana != NULL) { d_magnetometer.ana->mainloop(); }
// Update the matrix based on the change in time since the last
// update and the current values.
struct timeval now;
vrpn_gettimeofday(&now, NULL);
double delta_t = vrpn_TimevalDurationSeconds(now, d_prev_update_time);
update_matrix_based_on_values(delta_t);
d_prev_update_time = now;
// See if it has been long enough since our last report.
// If so, generate a new one.
double interval = vrpn_TimevalDurationSeconds(now, d_prevtime);
if (interval >= d_update_interval) {
// pack and deliver tracker report with info from the current matrix;
if (d_connection) {
char msgbuf[1000];
int len = encode_to(msgbuf);
if (d_connection->pack_message(len, vrpn_Tracker::timestamp,
position_m_id, d_sender_id, msgbuf,
vrpn_CONNECTION_LOW_LATENCY)) {
fprintf(stderr, "vrpn_IMU_SimpleCombiner: "
"cannot write pose message: tossing\n");
}
len = encode_vel_to(msgbuf);
if (d_connection->pack_message(len, vrpn_Tracker::timestamp,
velocity_m_id, d_sender_id, msgbuf,
vrpn_CONNECTION_LOW_LATENCY)) {
fprintf(stderr, "vrpn_IMU_SimpleCombiner: "
"cannot write velocity message: tossing\n");
}
} else {
fprintf(stderr, "vrpn_IMU_SimpleCombiner: "
"No valid connection\n");
}
// We just sent a report, so reset the time
d_prevtime = now;
}
}
void vrpn_Tracker_AnalogFly::mainloop()
{
struct timeval now;
double interval; // How long since the last report, in secs
// Call generic server mainloop, since we are a server
server_mainloop();
// Mainloop() all of the analogs that are defined and the button
// so that we will get all of the values fresh.
if (d_x.ana != NULL) { d_x.ana->mainloop(); };
if (d_y.ana != NULL) { d_y.ana->mainloop(); };
if (d_z.ana != NULL) { d_z.ana->mainloop(); };
if (d_sx.ana != NULL) { d_sx.ana->mainloop(); };
if (d_sy.ana != NULL) { d_sy.ana->mainloop(); };
if (d_sz.ana != NULL) { d_sz.ana->mainloop(); };
if (d_reset_button != NULL) { d_reset_button->mainloop(); };
if (d_clutch_button != NULL) { d_clutch_button->mainloop(); };
// See if it has been long enough since our last report.
// If so, generate a new one.
vrpn_gettimeofday(&now, NULL);
interval = vrpn_TimevalDurationSeconds(now, d_prevtime);
if (shouldReport(interval)) {
// Set the time on the report to now, if not an absolute
// tracker. Absolute trackers have their time values set
// to match the time at which their analog devices gave the
// last report.
if (!d_absolute) {
vrpn_Tracker::timestamp = now;
}
// Figure out the new matrix based on the current values and
// the length of the interval since the last report
update_matrix_based_on_values(interval);
// pack and deliver tracker report;
if (d_connection) {
char msgbuf[1000];
int len = encode_to(msgbuf);
if (d_connection->pack_message(len, vrpn_Tracker::timestamp,
position_m_id, d_sender_id, msgbuf,
vrpn_CONNECTION_LOW_LATENCY)) {
fprintf(stderr,"Tracker AnalogFly: "
"cannot write message: tossing\n");
}
} else {
fprintf(stderr,"Tracker AnalogFly: "
"No valid connection\n");
}
// We just sent a report, so reset the time
d_prevtime = now;
}
// We're not always sending reports, but we still want to
// update the interval clock so that we don't integrate over
// too long a timespan when we do finally report a change.
if (interval >= d_update_interval) {
d_prevtime = now;
}
}
