vrpn  07.33
Virtual Reality Peripheral Network
vrpn_Tracker_Crossbow.C
Go to the documentation of this file.
1 // vrpn_Tracker_Crossbow.h
2 // This file contains the implementation for a Crossbow RGA300CA Tracker.
3 
4 #include <math.h> // for cos, sin
5 #include <stdio.h> // for fprintf, stderr, NULL
6 #include <stdlib.h> // for realloc, free
7 #include <string.h> // for memset
8 
9 #include "quat.h" // for q_from_euler, Q_W, Q_X, Q_Y, etc
10 #include "vrpn_Connection.h" // for vrpn_CONNECTION_LOW_LATENCY, etc
11 #include "vrpn_Serial.h"
12 #include "vrpn_Tracker_Crossbow.h"
13 
14 // Conversion multiplier from degrees to radians (Pi radians per 180 degrees)
15 #define DEGREES_TO_RADIANS (3.1415926535897 / 180)
16 // Conversion multiplier from Gs to meters-per-second-per-second (~9.8 m/s^2 on Earth)
17 #define MPSS_PER_G (9.80665)
18 
19 vrpn_Tracker_Crossbow::vrpn_Tracker_Crossbow(const char *name, vrpn_Connection *c, const char *port, long baud,
20  float g_range, float ar_range) : vrpn_Tracker_Serial(name, c, port, baud), just_read_something(0),
21  lin_accel_range(g_range), ang_accel_range(ar_range), device_version(0), device_serial(0)
22 {
23 }
24 
26  if (device_version) {
27  free(device_version);
28  device_version = 0;
29  }
30 }
31 
32 // Retrieves a raw_packet from an incoming byte array, and even flips endianness as necessary.
33 void vrpn_Tracker_Crossbow::unbuffer_packet(raw_packet &dest, unsigned char *buffer) {
34  vrpn_unbuffer(&buffer, &dest.header);
37  vrpn_unbuffer(&buffer, &dest.yaw_rate);
38  vrpn_unbuffer(&buffer, &dest.accel_x);
39  vrpn_unbuffer(&buffer, &dest.accel_y);
40  vrpn_unbuffer(&buffer, &dest.accel_z);
41  vrpn_unbuffer(&buffer, &dest.timer);
44  vrpn_unbuffer(&buffer, &dest.status);
45  vrpn_unbuffer(&buffer, &dest.checksum);
46 }
47 
49 
50  // Allow accessing the packet as a string of bytes
51  union {
52  raw_packet packet;
53  vrpn_uint8 bytes[sizeof(raw_packet)];
54  } aligned;
55  aligned.packet = packet;
56 
57  // Check the header for the magic number
58  if (packet.header != 0xAA55) {
59  fprintf(stderr, "vrpn_Tracker_Crossbow: Received packet with invalid header $%02X%02X (should be $AA55)\n",
60  aligned.bytes[0], aligned.bytes[1]);
61  return 1;
62  }
63 
64  // Now calculate the expected checksum
65  vrpn_uint16 checksum = 0;
66  for (int i = 2; i < 22; i++)
67  checksum += aligned.bytes[i];
68 
69  // And compare the two checksum values.
70  if (checksum != packet.checksum) {
71  fprintf(stderr, "vrpn_Tracker_Crossbow: Received packet with invalid checksum $%04X (should be $%04X)\n",
72  packet.checksum, checksum);
73  return 1;
74  }
75 
76  return 0;
77 }
78 
80  struct timeval timeout;
81 
82  timeout.tv_sec = 0;
83  timeout.tv_usec = 500000; // Half a second
84 
85  switch (status) {
87  fprintf(stderr, "vrpn_Tracker_Crossbow: sanity: should never enter AWAITING_STATION state\n");
88  return 0;
89 
90  case vrpn_TRACKER_SYNCING: {
91  int rv;
92 
93  // Quit early if we just got a packet
94  if (just_read_something) {
96  return 0;
97  }
98 
99  // Request a packet from the device
100  unsigned char echo = 'G';
101  vrpn_write_characters(serial_fd, &echo, 1);
102 
103  rv = vrpn_read_available_characters(serial_fd, buffer, 1, &timeout);
104  // Return early if no characters are available
105  if (!rv)
106  return 0;
107 
108  // Return early if we aren't at the start of a packet header
109  if (*buffer != 0xAA) {
110  return 0;
111  }
112 
113  bufcount = 1;
114 
116 
117  // Fall through to next state
118  }
119 
120  case vrpn_TRACKER_PARTIAL: {
121  int rv;
122 
123  if (bufcount == 1) {
124  rv = vrpn_read_available_characters(serial_fd, buffer + 1, 1, &timeout);
125  if (!rv || (buffer[1] != 0x55)) {
126  buffer[0] = 0;
127  bufcount = 0;
129  return 0;
130  }
131  bufcount++;
132  }
133 
134  // Try to read the rest of the packet. Return early if we haven't got a full packet yet.
136  bufcount += rv;
137  if (bufcount < 24)
138  return 0;
139 
140  raw_packet new_data;
141  unbuffer_packet(new_data, &buffer[0]);
142 
143  // Ensure the packet is valid
144  if (validate_packet(new_data)) {
147  return 0;
148  }
149 
150  // Prepare the new report
151  process_packet(new_data);
152 
153  bufcount = 0;
154  memset(buffer, 0, 24);
157  return 1;
158  }
159 
160  default:
161  fprintf(stderr, "vrpn_Tracker_Crossbow: sanity: unknown tracker state\n");
162  return 0;
163  }
164 }
165 
167  const char *cmd;
168  unsigned char recv_buf[8];
169  struct timeval timeout;
170 
171  timeout.tv_sec = 1;
172  timeout.tv_usec = 0;
173 
174 #if 0 // doesn't help
175  // First, take the comm port offline for a second
177  vrpn_SleepMsecs(1000);
179 #endif
180 
183 
184  // Try resetting by toggling the RTS line of the serial port
186  vrpn_SleepMsecs(750);
188  vrpn_SleepMsecs(250);
190 
192 
193  cmd = "P";
194  vrpn_write_characters(serial_fd, reinterpret_cast<const unsigned char*> (cmd), 1);
195  vrpn_SleepMsecs(50); // Sleep long enough to stop receiving data
197 
198  cmd = "RSv";
199  vrpn_write_characters(serial_fd, reinterpret_cast<const unsigned char*> (cmd), 3);
201  if (vrpn_read_available_characters(serial_fd, recv_buf, 8, &timeout) != 8) {
202  fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow not responding to stimulus\n");
204  return;
205  }
206 
207  if ((recv_buf[0] != 'H') || (recv_buf[1] != 255) || (recv_buf[7] != 255)) {
208  fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow gave unexpected ping response\n");
210  return;
211  }
212 
213  if (recv_buf[6] != ((recv_buf[2] + recv_buf[3] + recv_buf[4] + recv_buf[5]) & 0xFF)) {
214  fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow gave invalid serial number checksum\n");
216  return;
217  }
218 
219  const char *bufptr = reinterpret_cast<const char *>(&recv_buf[2]);
220  vrpn_unbuffer(&bufptr, &device_serial);
221 
222  if (0) do {
223  if (!vrpn_read_available_characters(serial_fd, recv_buf, 1, &timeout)) {
224  fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow not responding to stimulus\n");
226  return;
227  }
228  } while (*recv_buf != 255);
229 
230  int curSize = 4, curLen = 0;
231  device_version = (char *) realloc(device_version, curSize * sizeof(char));
232  if (device_version == NULL) {
233  fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Out of memory\n");
235  return;
236  }
237  do {
238  if (!vrpn_read_available_characters(serial_fd, recv_buf, 1, &timeout)) {
239  fprintf(stderr, "vrpn_Tracker_Crossbow::reset: Crossbow not responding to stimulus\n");
241  return;
242  }
243  if (*recv_buf != '$')
244  device_version[curLen++] = *recv_buf;
245 
246  if (curLen == curSize)
247  device_version = (char *) realloc(device_version, curSize *= 2);
248  } while (*recv_buf != '$');
249 
250  // Now null-terminate the version string, expanding it one last time if necessary
251  if (curLen == curSize)
252  device_version = (char *) realloc(device_version, ++curSize);
253 
254  device_version[curLen] = 0;
255 
256  //printf("Serial %u\tVersion '%s'\n", device_serial, device_version);
257 
260 
261 }
262 
264  unsigned char buffer = 'R';
265  struct timeval timeout;
266 
268 
269  timeout.tv_sec = 1;
270  timeout.tv_usec = 0;
271 
272  while (vrpn_read_available_characters(serial_fd, &buffer, 1, &timeout) == 1) {
273  if (buffer == 'H')
274  return;
275  }
276 
277  fprintf(stderr, "vrpn_Tracker_Crossbow: Crossbow device not responding to ping\n");
278 }
279 
280 void vrpn_Tracker_Crossbow::recalibrate(vrpn_uint16 num_samples) {
281  if (num_samples < 100) {
282  fprintf(stderr, "vrpn_Tracker_Crossbow: Must recalibrate using at least 100 samples\n");
283  return;
284  }
285  else if (num_samples > 25599) {
286  fprintf(stderr, "vrpn_Tracker_Crossbow: Capping recalibration at 25,500 samples\n");
287  num_samples = 25500;
288  }
289 
292 
293  // Prepare zero command
294  unsigned char buffer[2];
295  buffer[0] = 'z';
296  buffer[1] = (unsigned char) (num_samples / 100);
297 
300  vrpn_SleepMsecs(50);
301 
302  // Wait for affirmative response.
303  // Allow two minutes before timing out.
304  // Even 25500 samples should make it with a few seconds to spare.
305  struct timeval timeout;
306  timeout.tv_sec = 120;
307  timeout.tv_usec = 0;
308  if (!vrpn_read_available_characters(serial_fd, buffer, 1, &timeout) || *buffer != 'Z') {
309  fprintf(stderr, "vrpn_Tracker_Crossbow: Failed to recalibrate device\n");
310  }
311 }
312 
314  if (!device_serial)
315  reset();
316  return device_serial;
317 }
318 
320  if (!device_version)
321  reset();
322  return device_version;
323 }
324 
325 
328 }
329 
330 // Utility function to convert packed inputs into decoded floating-point equivalents.
331 float vrpn_Tracker_Crossbow::convert_scalar(vrpn_int16 data, float scale) const {
332  return data * scale / 32768; // 2^15
333 }
334 
336  // Use the current time for a timestamp.
338 
339  // Clear the position record.
340  memset(pos, 0, sizeof(pos));
341 
342  // Calculate the current orientation. (We don't know yaw, so report 0.)
343  double pitch = convert_scalar(packet.pitch_angle, 180.0f) * DEGREES_TO_RADIANS;
344  double roll = convert_scalar(packet.roll_angle, 180.0f) * DEGREES_TO_RADIANS;
345  xb_quat_from_euler(d_quat, pitch, roll);
346 
347  // Clear the linear velocity; we don't know it.
348  memset(vel, 0, sizeof(vel));
349 
350  // Calculate the current angular velocity from yaw rate
351  // It's in degrees per second, so convert to radians per second.
352  q_from_euler(vel_quat, convert_scalar(packet.yaw_rate, 1.5f * ang_accel_range) * DEGREES_TO_RADIANS, 0, 0);
353  vel_quat_dt = 1;
354 
355  // Calculate the current acceleration vector
356  acc[0] = convert_scalar(packet.accel_x, 1.5f * lin_accel_range) * MPSS_PER_G;
357  acc[1] = convert_scalar(packet.accel_y, 1.5f * lin_accel_range) * MPSS_PER_G;
358  acc[2] = convert_scalar(packet.accel_z, 1.5f * lin_accel_range) * MPSS_PER_G;
359 
360  //printf("RawAccel = %hd\tG-Range = %f\tDerivedZ = %f\n", packet.accel_z, lin_accel_range, acc[2]);
361 
362  // The angular acceleration vector is nil. (0001 / 1)
363  acc_quat[0] = acc_quat[1] = acc_quat[2] = 0;
364  acc_quat[3] = acc_quat_dt = 1;
365 }
366 
368  // Send the message on the connection
369  if (d_connection) {
370  char msgbuf[1000];
371  int len = encode_to(msgbuf);
373  fprintf(stderr,"Tracker: cannot write message: tossing\n");
374  }
375 
376  len = encode_acc_to(msgbuf);
378  fprintf(stderr,"Tracker: cannot write message: tossing\n");
379  }
380 
381  len = encode_vel_to(msgbuf);
383  fprintf(stderr,"Tracker: cannot write message: tossing\n");
384  }
385  } else {
386  fprintf(stderr,"Tracker: No valid connection\n");
387  }
388 }
389 
390 // Creates orientation quaternion from pitch and roll Euler angles.
391 // Crossbow angles are given such that p' = yaw(pitch(roll(p))),
392 // but quatlib angles assume p' = roll(pitch(yaw(p))).
393 // Hence the apparent reimplementation of q_from_euler.
394 void vrpn_Tracker_Crossbow::xb_quat_from_euler(q_type destQuat, double pitch, double roll) const {
395  double sinP = sin(pitch / 2.0);
396  double cosP = cos(pitch / 2.0);
397  double sinR = sin(roll / 2.0);
398  double cosR = cos(roll / 2.0);
399 
400  destQuat[Q_X] = sinP * cosR;
401  destQuat[Q_Y] = cosP * sinR;
402  destQuat[Q_Z] = -sinP * sinR;
403  destQuat[Q_W] = cosP * cosR;
404 }
405 
vrpn_Tracker::acc
vrpn_float64 acc[3]
Definition: vrpn_Tracker.h:98
vrpn_Tracker_Serial::portname
char portname[VRPN_TRACKER_BUF_SIZE]
Definition: vrpn_Tracker.h:151
vrpn_Tracker_Crossbow::raw_packet::roll_angle
vrpn_int16 roll_angle
Definition: vrpn_Tracker_Crossbow.h:56
vrpn_Connection::pack_message
virtual int pack_message(vrpn_uint32 len, struct timeval time, vrpn_int32 type, vrpn_int32 sender, const char *buffer, vrpn_uint32 class_of_service)
Pack a message that will be sent the next time mainloop() is called. Turn off the RELIABLE flag if yo...
Definition: vrpn_Connection.C:4632
vrpn_Tracker_Crossbow::raw_packet::accel_y
vrpn_int16 accel_y
Definition: vrpn_Tracker_Crossbow.h:60
vrpn_Tracker::vel
vrpn_float64 vel[3]
Definition: vrpn_Tracker.h:96
vrpn_Tracker_Crossbow::vrpn_Tracker_Crossbow
vrpn_Tracker_Crossbow(const char *name, vrpn_Connection *c, const char *port="/dev/ttyS0", long baud=38400, float g_range=2.0f, float ar_range=100.0f)
The constructor is given the name of the tracker (the name of the sender it should use),...
Definition: vrpn_Tracker_Crossbow.C:19
vrpn_Tracker_Crossbow::raw_packet::accel_z
vrpn_int16 accel_z
Definition: vrpn_Tracker_Crossbow.h:61
vrpn_Tracker::encode_to
virtual int encode_to(char *buf)
Definition: vrpn_Tracker.C:533
vrpn_Tracker_Crossbow::device_serial
vrpn_uint32 device_serial
Definition: vrpn_Tracker_Crossbow.h:73
vrpn_Tracker_Crossbow::process_packet
void process_packet(const raw_packet &packet)
Definition: vrpn_Tracker_Crossbow.C:335
vrpn_Tracker_Crossbow::validate_packet
int validate_packet(const raw_packet &packet)
Definition: vrpn_Tracker_Crossbow.C:48
vrpn_Tracker_Serial::buffer
unsigned char buffer[VRPN_TRACKER_BUF_SIZE]
Definition: vrpn_Tracker.h:155
vrpn_set_rts
int vrpn_set_rts(int comm)
Definition: vrpn_Serial.C:365
vrpn_drain_output_buffer
int vrpn_drain_output_buffer(int comm)
Wait until all of the characters in the output buffer are sent, then return.
Definition: vrpn_Serial.C:485
vrpn_Tracker_Crossbow::lin_accel_range
float lin_accel_range
Definition: vrpn_Tracker_Crossbow.h:70
vrpn_Tracker_Crossbow::ang_accel_range
float ang_accel_range
Definition: vrpn_Tracker_Crossbow.h:71
vrpn_Tracker_Serial::serial_fd
int serial_fd
Definition: vrpn_Tracker.h:153
vrpn_Tracker_Crossbow::raw_packet::pitch_angle
vrpn_int16 pitch_angle
Definition: vrpn_Tracker_Crossbow.h:57
vrpn_Tracker::d_quat
vrpn_float64 d_quat[4]
Definition: vrpn_Tracker.h:95
vrpn_Tracker::velocity_m_id
vrpn_int32 velocity_m_id
Definition: vrpn_Tracker.h:81
vrpn_Tracker::encode_vel_to
virtual int encode_vel_to(char *buf)
Definition: vrpn_Tracker.C:558
vrpn_Tracker::timestamp
struct timeval timestamp
Definition: vrpn_Tracker.h:100
vrpn_Tracker_Crossbow::convert_scalar
float convert_scalar(vrpn_int16 data, float scale) const
Definition: vrpn_Tracker_Crossbow.C:331
vrpn_Tracker_Crossbow::raw_packet::temp_voltage
vrpn_int16 temp_voltage
Definition: vrpn_Tracker_Crossbow.h:63
vrpn_Serial.h
vrpn_Serial: Pulls all the serial port routines into one file to make porting to new operating system...
vrpn_Tracker_Crossbow::recalibrate
void recalibrate(vrpn_uint16 num_samples=20000)
Definition: vrpn_Tracker_Crossbow.C:280
vrpn_Tracker_Crossbow::reset
void reset()
Reset the tracker.
Definition: vrpn_Tracker_Crossbow.C:166
vrpn_Tracker_Crossbow::get_version_string
const char * get_version_string()
Definition: vrpn_Tracker_Crossbow.C:319
vrpn_CONNECTION_LOW_LATENCY
const vrpn_uint32 vrpn_CONNECTION_LOW_LATENCY
Definition: vrpn_Connection.h:122
vrpn_unbuffer
VRPN_API int vrpn_unbuffer(const char **buffer, timeval *t)
Utility routine for taking a struct timeval from a buffer that was sent as a message.
Definition: vrpn_Shared.C:312
vrpn_Tracker::acc_quat
vrpn_float64 acc_quat[4]
Definition: vrpn_Tracker.h:98
vrpn_Tracker::accel_m_id
vrpn_int32 accel_m_id
Definition: vrpn_Tracker.h:82
vrpn_BaseClassUnique::d_connection
vrpn_Connection * d_connection
Connection that this object talks to.
Definition: vrpn_BaseClass.h:224
vrpn_flush_input_buffer
int vrpn_flush_input_buffer(int comm)
Throw out any characters within the input buffer.
Definition: vrpn_Serial.C:435
vrpn_SleepMsecs
void vrpn_SleepMsecs(double dMsecs)
Definition: vrpn_Shared.C:157
vrpn_Tracker_Crossbow::~vrpn_Tracker_Crossbow
~vrpn_Tracker_Crossbow()
Definition: vrpn_Tracker_Crossbow.C:25
vrpn_TRACKER_PARTIAL
const int vrpn_TRACKER_PARTIAL
Definition: vrpn_Tracker.h:38
vrpn_Tracker_Crossbow::raw_packet
Definition: vrpn_Tracker_Crossbow.h:54
vrpn_Tracker_Crossbow::raw_packet::checksum
vrpn_uint16 checksum
Definition: vrpn_Tracker_Crossbow.h:66
vrpn_Tracker_Crossbow::raw_packet::timer
vrpn_uint16 timer
Definition: vrpn_Tracker_Crossbow.h:62
vrpn_Tracker_Crossbow::raw_packet::part_number
vrpn_int16 part_number
Definition: vrpn_Tracker_Crossbow.h:64
vrpn_BaseClassUnique::d_sender_id
vrpn_int32 d_sender_id
Sender ID registered with the connection.
Definition: vrpn_BaseClass.h:228
vrpn_Tracker_Crossbow::ping
void ping()
Definition: vrpn_Tracker_Crossbow.C:263
vrpn_Tracker_Crossbow::get_report
int get_report()
Gets a report if one is available, returns 0 if not, 1 if complete report.
Definition: vrpn_Tracker_Crossbow.C:79
vrpn_Tracker_Serial::mainloop
virtual void mainloop()
Uses the get_report, send_report, and reset routines to implement a server.
Definition: vrpn_Tracker.C:907
vrpn_Tracker_Crossbow::just_read_something
int just_read_something
Definition: vrpn_Tracker_Crossbow.h:76
vrpn_Tracker::acc_quat_dt
vrpn_float64 acc_quat_dt
Definition: vrpn_Tracker.h:99
vrpn_Tracker_Crossbow::raw_packet::status
vrpn_int16 status
Definition: vrpn_Tracker_Crossbow.h:65
vrpn_Tracker::encode_acc_to
virtual int encode_acc_to(char *buf)
Definition: vrpn_Tracker.C:585
vrpn_Tracker::position_m_id
vrpn_int32 position_m_id
Definition: vrpn_Tracker.h:80
vrpn_Connection
Generic connection class not specific to the transport mechanism.
Definition: vrpn_Connection.h:510
vrpn_Connection.h
vrpn_TRACKER_FAIL
const int vrpn_TRACKER_FAIL
Definition: vrpn_Tracker.h:40
vrpn_Tracker_Crossbow::xb_quat_from_euler
void xb_quat_from_euler(q_type destQuat, double pitch, double roll) const
Definition: vrpn_Tracker_Crossbow.C:394
vrpn_Tracker_Crossbow::unbuffer_packet
void unbuffer_packet(raw_packet &dest, unsigned char *buffer)
Definition: vrpn_Tracker_Crossbow.C:33
vrpn_gettimeofday
#define vrpn_gettimeofday
Definition: vrpn_Shared.h:89
vrpn_Tracker::status
int status
Definition: vrpn_Tracker.h:129
vrpn_Tracker_Serial
Definition: vrpn_Tracker.h:144
vrpn_Tracker_Crossbow::send_report
void send_report()
Definition: vrpn_Tracker_Crossbow.C:367
vrpn_read_available_characters
int vrpn_read_available_characters(int comm, unsigned char *buffer, size_t bytes)
Definition: vrpn_Serial.C:512
vrpn_close_commport
int vrpn_close_commport(int comm)
Definition: vrpn_Serial.C:345
vrpn_Tracker_Crossbow::raw_packet::accel_x
vrpn_int16 accel_x
Definition: vrpn_Tracker_Crossbow.h:59
vrpn_Tracker::vel_quat
vrpn_float64 vel_quat[4]
Definition: vrpn_Tracker.h:96
vrpn_TRACKER_SYNCING
const int vrpn_TRACKER_SYNCING
Definition: vrpn_Tracker.h:35
vrpn_Tracker_Crossbow::get_serial_number
vrpn_uint32 get_serial_number()
Definition: vrpn_Tracker_Crossbow.C:313
vrpn_Tracker_Serial::bufcount
vrpn_uint32 bufcount
Definition: vrpn_Tracker.h:157
vrpn_Tracker_Serial::baudrate
long baudrate
Definition: vrpn_Tracker.h:152
vrpn_Tracker_Crossbow::raw_packet::yaw_rate
vrpn_int16 yaw_rate
Definition: vrpn_Tracker_Crossbow.h:58
vrpn_TRACKER_AWAITING_STATION
const int vrpn_TRACKER_AWAITING_STATION
Definition: vrpn_Tracker.h:36
vrpn_write_characters
int vrpn_write_characters(int comm, const unsigned char *buffer, size_t bytes)
Write the buffer to the serial port.
Definition: vrpn_Serial.C:643
vrpn_open_commport
int vrpn_open_commport(const char *portname, long baud, int charsize, vrpn_SER_PARITY parity, bool rts_flow)
Open a serial port, given its name and baud rate.
Definition: vrpn_Serial.C:54
DEGREES_TO_RADIANS
#define DEGREES_TO_RADIANS
Definition: vrpn_Tracker_Crossbow.C:15
vrpn_Tracker_Crossbow::raw_packet::header
vrpn_uint16 header
Definition: vrpn_Tracker_Crossbow.h:55
MPSS_PER_G
#define MPSS_PER_G
Definition: vrpn_Tracker_Crossbow.C:17
vrpn_Tracker::pos
vrpn_float64 pos[3]
Definition: vrpn_Tracker.h:95
vrpn_Tracker_Crossbow::device_version
char * device_version
Definition: vrpn_Tracker_Crossbow.h:74
vrpn_Tracker::vel_quat_dt
vrpn_float64 vel_quat_dt
Definition: vrpn_Tracker.h:97
vrpn_flush_output_buffer
int vrpn_flush_output_buffer(int comm)
Throw out any characters (do not send) within the output buffer.
Definition: vrpn_Serial.C:462
vrpn_Tracker_Crossbow::mainloop
virtual void mainloop()
Uses the get_report, send_report, and reset routines to implement a server.
Definition: vrpn_Tracker_Crossbow.C:326
vrpn_Tracker_Crossbow.h
vrpn_clear_rts
int vrpn_clear_rts(int comm)
Definition: vrpn_Serial.C:399