The open source OpenXR runtime
d/vive/controller: Port to u_logging.
+81
-124
+17
-18
src/xrt/drivers/vive/vive_config.c
+17
-18
src/xrt/drivers/vive/vive_config.c
···
14
14
#include "util/u_json.h"
15
15
#include "math/m_api.h"
16
16
17
+
#include "vive.h"
17
18
#include "vive_device.h"
18
19
#include "vive_controller.h"
19
20
···
208
209
static void
209
210
_print_vec3(const char *title, struct xrt_vec3 *vec)
210
211
{
211
-
printf("%s = %f %f %f\n", title, (double)vec->x, (double)vec->y,
212
-
(double)vec->z);
212
+
U_LOG_D("%s = %f %f %f", title, (double)vec->x, (double)vec->y,
213
+
(double)vec->z);
213
214
}
214
215
215
216
bool
···
338
339
vive_config_parse_controller(struct vive_controller_device *d,
339
340
char *json_string)
340
341
{
341
-
VIVE_CONTROLLER_DEBUG(d, "JSON config:\n%s", json_string);
342
+
VIVE_DEBUG(d, "JSON config:\n%s", json_string);
342
343
343
344
cJSON *json = cJSON_Parse(json_string);
344
345
if (!cJSON_IsObject(json)) {
345
-
VIVE_CONTROLLER_ERROR(d, "Could not parse JSON data.");
346
+
VIVE_ERROR(d, "Could not parse JSON data.");
346
347
return false;
347
348
}
348
349
···
355
356
356
357
if (strcmp(d->firmware.model_number, "Vive. Controller MV") == 0) {
357
358
d->variant = CONTROLLER_VIVE_WAND;
358
-
VIVE_CONTROLLER_DEBUG(d, "Found Vive Wand controller");
359
+
VIVE_DEBUG(d, "Found Vive Wand controller");
359
360
} else if (strcmp(d->firmware.model_number, "Knuckles Right") == 0) {
360
361
d->variant = CONTROLLER_INDEX_RIGHT;
361
-
VIVE_CONTROLLER_DEBUG(d, "Found Knuckles Right controller");
362
+
VIVE_DEBUG(d, "Found Knuckles Right controller");
362
363
} else if (strcmp(d->firmware.model_number, "Knuckles Left") == 0) {
363
364
d->variant = CONTROLLER_INDEX_LEFT;
364
-
VIVE_CONTROLLER_DEBUG(d, "Found Knuckles Left controller");
365
+
VIVE_DEBUG(d, "Found Knuckles Left controller");
365
366
} else if (strcmp(d->firmware.model_number, "Vive Tracker PVT") == 0) {
366
367
d->variant = CONTROLLER_TRACKER_GEN1;
367
-
VIVE_CONTROLLER_DEBUG(d, "Found Gen 1 tracker.");
368
+
VIVE_DEBUG(d, "Found Gen 1 tracker.");
368
369
} else if (strcmp(d->firmware.model_number, "VIVE Tracker Pro MV") ==
369
370
0) {
370
371
d->variant = CONTROLLER_TRACKER_GEN2;
371
-
VIVE_CONTROLLER_DEBUG(d, "Found Gen 2 tracker.");
372
+
VIVE_DEBUG(d, "Found Gen 2 tracker.");
372
373
} else {
373
-
VIVE_CONTROLLER_ERROR(d, "Failed to parse controller variant");
374
+
VIVE_ERROR(d, "Failed to parse controller variant");
374
375
}
375
376
376
377
switch (d->variant) {
···
396
397
if (d->variant == CONTROLLER_TRACKER_GEN2)
397
398
JSON_VEC3(imu, "gyro_scale", &d->imu.gyro_scale);
398
399
} break;
399
-
default:
400
-
VIVE_CONTROLLER_ERROR(d, "Unknown Vive watchman variant.\n");
401
-
return false;
400
+
default: VIVE_ERROR(d, "Unknown Vive watchman variant."); return false;
402
401
}
403
402
404
403
JSON_STRING(json, "device_serial_number",
···
407
406
cJSON_Delete(json);
408
407
409
408
// clang-format off
410
-
VIVE_CONTROLLER_DEBUG(d, "= Vive controller configuration =");
409
+
VIVE_DEBUG(d, "= Vive controller configuration =");
411
410
412
-
VIVE_CONTROLLER_DEBUG(d, "model_number: %s", d->firmware.model_number);
413
-
VIVE_CONTROLLER_DEBUG(d, "mb_serial_number: %s", d->firmware.mb_serial_number);
414
-
VIVE_CONTROLLER_DEBUG(d, "device_serial_number: %s", d->firmware.device_serial_number);
411
+
VIVE_DEBUG(d, "model_number: %s", d->firmware.model_number);
412
+
VIVE_DEBUG(d, "mb_serial_number: %s", d->firmware.mb_serial_number);
413
+
VIVE_DEBUG(d, "device_serial_number: %s", d->firmware.device_serial_number);
415
414
416
-
if (d->print_debug) {
415
+
if (d->ll <= U_LOGGING_DEBUG) {
417
416
_print_vec3("acc_bias", &d->imu.acc_bias);
418
417
_print_vec3("acc_scale", &d->imu.acc_scale);
419
418
_print_vec3("gyro_bias", &d->imu.gyro_bias);
+62
-79
src/xrt/drivers/vive/vive_controller.c
+62
-79
src/xrt/drivers/vive/vive_controller.c
···
31
31
#include "os/os_threading.h"
32
32
#include "os/os_time.h"
33
33
34
+
#include "vive.h"
34
35
#include "vive_protocol.h"
35
36
#include "vive_controller.h"
36
37
#include "vive_config.h"
···
46
47
*
47
48
*/
48
49
49
-
DEBUG_GET_ONCE_BOOL_OPTION(vive_controller_spew,
50
-
"VIVE_CONTROLLER_PRINT_SPEW",
51
-
false)
52
-
DEBUG_GET_ONCE_BOOL_OPTION(vive_controller_debug,
53
-
"VIVE_CONTROLLER_PRINT_DEBUG",
54
-
false)
50
+
DEBUG_GET_ONCE_LOG_OPTION(vive_log, "VIVE_LOG", U_LOGGING_WARN)
51
+
55
52
enum vive_controller_input_index
56
53
{
57
54
// common inputs
···
155
152
input->timestamp = now;
156
153
input->value.boolean = pressed;
157
154
158
-
VIVE_CONTROLLER_DEBUG(d, "button %d %s\n", i,
159
-
pressed ? "pressed" : "released");
155
+
VIVE_DEBUG(d, "button %d %s\n", i,
156
+
pressed ? "pressed" : "released");
160
157
}
161
158
}
162
159
d->state.last_buttons = d->state.buttons;
···
167
164
trackpad_input->timestamp = now;
168
165
trackpad_input->value.vec2.x = d->state.trackpad.x;
169
166
trackpad_input->value.vec2.y = d->state.trackpad.y;
170
-
VIVE_CONTROLLER_SPEW(d, "Trackpad: %f, %f", d->state.trackpad.x,
171
-
d->state.trackpad.y);
167
+
VIVE_TRACE(d, "Trackpad: %f, %f", d->state.trackpad.x,
168
+
d->state.trackpad.y);
172
169
173
170
174
171
struct xrt_input *trigger_input =
175
172
&d->base.inputs[VIVE_CONTROLLER_INDEX_TRIGGER_VALUE];
176
173
trigger_input->timestamp = now;
177
174
trigger_input->value.vec1.x = d->state.trigger;
178
-
VIVE_CONTROLLER_SPEW(d, "Trigger: %f", d->state.trigger);
175
+
VIVE_TRACE(d, "Trigger: %f", d->state.trigger);
179
176
180
177
os_thread_helper_unlock(&d->controller_thread);
181
178
}
···
224
221
input->timestamp = now;
225
222
input->value.boolean = pressed;
226
223
227
-
VIVE_CONTROLLER_DEBUG(d, "button %d %s\n", i,
228
-
pressed ? "pressed" : "released");
224
+
VIVE_DEBUG(d, "button %d %s\n", i,
225
+
pressed ? "pressed" : "released");
229
226
}
230
227
}
231
228
d->state.last_buttons = d->state.buttons;
···
251
248
const char *component = is_trackpad_touched || was_trackpad_touched
252
249
? "Trackpad"
253
250
: "Thumbstick";
254
-
VIVE_CONTROLLER_SPEW(d, "%s: %f, %f", component, d->state.trackpad.x,
255
-
d->state.trackpad.y);
251
+
VIVE_TRACE(d, "%s: %f, %f", component, d->state.trackpad.x,
252
+
d->state.trackpad.y);
256
253
257
254
258
255
struct xrt_input *trigger_input =
···
261
258
trigger_input->timestamp = now;
262
259
trigger_input->value.vec1.x = d->state.trigger;
263
260
264
-
VIVE_CONTROLLER_SPEW(d, "Trigger: %f", d->state.trigger);
261
+
VIVE_TRACE(d, "Trigger: %f", d->state.trigger);
265
262
266
263
267
264
/* d->state.touch is bitmask of currently touched buttons.
···
289
286
input->timestamp = now;
290
287
input->value.boolean = touched;
291
288
292
-
VIVE_CONTROLLER_DEBUG(d, "button %d %s\n", i,
293
-
touched ? "touched"
294
-
: "untouched");
289
+
VIVE_DEBUG(d, "button %d %s\n", i,
290
+
touched ? "touched" : "untouched");
295
291
}
296
292
}
297
293
d->state.last_touch = d->state.touch;
···
300
296
(float)d->state.squeeze_force / UINT8_MAX;
301
297
d->base.inputs[VIVE_CONTROLLER_INDEX_SQUEEZE_FORCE].timestamp = now;
302
298
if (d->state.squeeze_force > 0) {
303
-
VIVE_CONTROLLER_DEBUG(d, "Squeeze force: %f\n",
304
-
(float)d->state.squeeze_force /
305
-
UINT8_MAX);
299
+
VIVE_DEBUG(d, "Squeeze force: %f\n",
300
+
(float)d->state.squeeze_force / UINT8_MAX);
306
301
}
307
302
308
303
d->base.inputs[VIVE_CONTROLLER_INDEX_TRACKPAD_FORCE].value.vec1.x =
309
304
(float)d->state.trackpad_force / UINT8_MAX;
310
305
d->base.inputs[VIVE_CONTROLLER_INDEX_TRACKPAD_FORCE].timestamp = now;
311
306
if (d->state.trackpad_force > 0) {
312
-
VIVE_CONTROLLER_DEBUG(d, "Trackpad force: %f\n",
313
-
(float)d->state.trackpad_force /
314
-
UINT8_MAX);
307
+
VIVE_DEBUG(d, "Trackpad force: %f\n",
308
+
(float)d->state.trackpad_force / UINT8_MAX);
315
309
}
316
310
317
311
os_thread_helper_unlock(&d->controller_thread);
···
338
332
name != XRT_INPUT_VIVE_GRIP_POSE &&
339
333
name != XRT_INPUT_INDEX_AIM_POSE &&
340
334
name != XRT_INPUT_INDEX_GRIP_POSE) {
341
-
VIVE_CONTROLLER_ERROR(d, "unknown input name");
335
+
VIVE_ERROR(d, "unknown input name");
342
336
return;
343
337
}
344
338
···
369
363
370
364
struct xrt_vec3 pos = out_relation->pose.position;
371
365
struct xrt_quat quat = out_relation->pose.orientation;
372
-
VIVE_CONTROLLER_SPEW(
373
-
d, "GET_TRACKED_POSE (%f, %f, %f) (%f, %f, %f, %f) ", pos.x, pos.y,
374
-
pos.z, quat.x, quat.y, quat.z, quat.w);
366
+
VIVE_TRACE(d, "GET_TRACKED_POSE (%f, %f, %f) (%f, %f, %f, %f) ", pos.x,
367
+
pos.y, pos.z, quat.x, quat.y, quat.z, quat.w);
375
368
}
376
369
377
370
static int
···
381
374
float duration_seconds;
382
375
//! @todo: proper min duration value
383
376
if (value->vibration.duration == -1) {
384
-
VIVE_CONTROLLER_SPEW(d,
385
-
"Haptic pulse duration: using %f minimum",
386
-
MIN_HAPTIC_DURATION);
377
+
VIVE_TRACE(d, "Haptic pulse duration: using %f minimum",
378
+
MIN_HAPTIC_DURATION);
387
379
duration_seconds = 0.1;
388
380
} else {
389
381
duration_seconds = time_ns_to_s(value->vibration.duration);
390
382
}
391
383
392
-
VIVE_CONTROLLER_SPEW(d, "Haptic pulse amp %f, %fHz, %fs",
393
-
value->vibration.amplitude,
394
-
value->vibration.frequency, duration_seconds);
384
+
VIVE_TRACE(d, "Haptic pulse amp %f, %fHz, %fs",
385
+
value->vibration.amplitude, value->vibration.frequency,
386
+
duration_seconds);
395
387
float frequency = value->vibration.frequency;
396
388
397
389
//! @todo: proper unspecified value
398
390
if (frequency == 0) {
399
-
VIVE_CONTROLLER_SPEW(
391
+
VIVE_TRACE(
400
392
d, "Haptic pulse frequency unspecified, setting to %fHz",
401
393
DEFAULT_HAPTIC_FREQ);
402
394
frequency = 200;
···
449
441
450
442
if (name != XRT_OUTPUT_NAME_VIVE_HAPTIC &&
451
443
name != XRT_OUTPUT_NAME_INDEX_HAPTIC) {
452
-
VIVE_CONTROLLER_ERROR(d, "Unknown output\n");
444
+
VIVE_ERROR(d, "Unknown output\n");
453
445
return;
454
446
}
455
447
···
468
460
uint8_t charge_percent =
469
461
sample->battery & VIVE_CONTROLLER_BATTERY_CHARGE_MASK;
470
462
bool charging = sample->battery & VIVE_CONTROLLER_BATTERY_CHARGING;
471
-
VIVE_CONTROLLER_DEBUG(d, "Charging %d, percent %d\n", charging,
472
-
charge_percent);
463
+
VIVE_DEBUG(d, "Charging %d, percent %d\n", charging, charge_percent);
473
464
d->state.charging = charging;
474
465
d->state.battery = charge_percent;
475
466
}
···
490
481
d->state.trackpad.x = (float)x / INT16_MAX;
491
482
d->state.trackpad.y = (float)y / INT16_MAX;
492
483
if (d->state.trackpad.x != 0 || d->state.trackpad.y != 0)
493
-
VIVE_CONTROLLER_SPEW(d, "Trackpad %f,%f\n", d->state.trackpad.x,
494
-
d->state.trackpad.y);
484
+
VIVE_TRACE(d, "Trackpad %f,%f\n", d->state.trackpad.x,
485
+
d->state.trackpad.y);
495
486
}
496
487
497
488
static void
···
499
490
struct vive_controller_trigger_sample *sample)
500
491
{
501
492
d->state.trigger = (float)sample->trigger / UINT8_MAX;
502
-
VIVE_CONTROLLER_SPEW(d, "Trigger %f\n", d->state.trigger);
493
+
VIVE_TRACE(d, "Trigger %f\n", d->state.trigger);
503
494
}
504
495
505
496
static inline uint32_t
···
563
554
scale * d->imu.gyro_scale.z * gyro[2] - d->imu.gyro_bias.z,
564
555
};
565
556
566
-
VIVE_CONTROLLER_SPEW(d, "ACC %f %f %f", acceleration.x, acceleration.y,
567
-
acceleration.z);
568
-
VIVE_CONTROLLER_SPEW(d, "GYRO %f %f %f", angular_velocity.x,
569
-
angular_velocity.y, angular_velocity.z);
557
+
VIVE_TRACE(d, "ACC %f %f %f", acceleration.x, acceleration.y,
558
+
acceleration.z);
559
+
VIVE_TRACE(d, "GYRO %f %f %f", angular_velocity.x, angular_velocity.y,
560
+
angular_velocity.z);
570
561
/*
571
562
*/
572
563
···
614
605
615
606
d->rot_filtered = d->fusion.rot;
616
607
617
-
// VIVE_CONTROLLER_SPEW(d, "Rot %f %f %f", d->rot_filtered.x,
608
+
// VIVE_TRACE(d, "Rot %f %f %f", d->rot_filtered.x,
618
609
// d->rot_filtered.y, d->rot_filtered.z);
619
610
}
620
611
···
638
629
uint8_t *buf,
639
630
uint8_t len)
640
631
{
641
-
VIVE_CONTROLLER_SPEW(d, "Got lighthouse message with len %d.\n", len);
632
+
VIVE_TRACE(d, "Got lighthouse message with len %d.\n", len);
642
633
}
643
634
644
635
/*
···
696
687
697
688
// clang-format on
698
689
699
-
VIVE_CONTROLLER_SPEW(d,
700
-
"battery %d trigger %d trackpad %d "
701
-
"buttons %d imu %d",
702
-
has_battery, has_trigger, has_trackpad,
703
-
has_buttons, has_imu);
690
+
VIVE_TRACE(d,
691
+
"battery %d trigger %d trackpad %d "
692
+
"buttons %d imu %d",
693
+
has_battery, has_trigger, has_trackpad, has_buttons,
694
+
has_imu);
704
695
705
696
buf++;
706
697
···
733
724
}
734
725
735
726
if (buf > end)
736
-
VIVE_CONTROLLER_ERROR(d, "overshoot: %ld\n", buf - end);
727
+
VIVE_ERROR(d, "overshoot: %ld\n", buf - end);
737
728
738
729
if (buf < end)
739
730
vive_controller_handle_lighthousev1(d, buf, end - buf);
···
918
909
#endif
919
910
920
911
if (buf < end) {
921
-
VIVE_CONTROLLER_ERROR(d, "%ld bytes unparsed data in message\n",
922
-
message->len - (buf - message->payload) -
923
-
1);
912
+
VIVE_TRACE(d, "%ld bytes unparsed data in message\n",
913
+
message->len - (buf - message->payload) - 1);
924
914
}
925
915
if (buf > end)
926
-
VIVE_CONTROLLER_ERROR(d, "overshoot: %ld\n", buf - end);
916
+
VIVE_ERROR(d, "overshoot: %ld\n", buf - end);
927
917
928
918
//! @todo: Parse lighthouse v2 data
929
919
}
···
946
936
case WATCHMAN_GEN2:
947
937
vive_controller_decode_watchmanv2(d, message);
948
938
break;
949
-
default: VIVE_CONTROLLER_ERROR(d, "Can't decode unknown watchman gen");
939
+
default: VIVE_ERROR(d, "Can't decode unknown watchman gen");
950
940
}
951
941
}
952
942
···
964
954
}
965
955
966
956
if (ret < 0) {
967
-
VIVE_CONTROLLER_ERROR(d, "Failed to read device '%i'!", ret);
957
+
VIVE_ERROR(d, "Failed to read device '%i'!", ret);
968
958
return false;
969
959
}
970
960
···
981
971
d, &((struct vive_controller_report2 *)buf)->message[1]);
982
972
break;
983
973
case VIVE_CONTROLLER_DISCONNECT_REPORT_ID:
984
-
VIVE_CONTROLLER_DEBUG(d, "Controller disconnected.");
974
+
VIVE_DEBUG(d, "Controller disconnected.");
985
975
break;
986
-
default:
987
-
VIVE_CONTROLLER_ERROR(d, "Unknown controller message type: %u",
988
-
buf[0]);
976
+
default: VIVE_ERROR(d, "Unknown controller message type: %u", buf[0]);
989
977
}
990
978
991
979
return true;
···
1038
1026
struct vive_controller_device *d = U_DEVICE_ALLOCATE(
1039
1027
struct vive_controller_device, flags, VIVE_CONTROLLER_MAX_INDEX, 1);
1040
1028
1041
-
d->print_spew = debug_get_bool_option_vive_controller_spew();
1042
-
d->print_debug = debug_get_bool_option_vive_controller_debug();
1029
+
d->ll = debug_get_log_option_vive_log();
1043
1030
d->watchman_gen = WATCHMAN_GEN_UNKNOWN;
1044
1031
d->variant = CONTROLLER_UNKNOWN;
1045
1032
···
1079
1066
//! @todo: reading range report fails for powered off controller
1080
1067
if (vive_get_imu_range_report(d->controller_hid, &d->imu.gyro_range,
1081
1068
&d->imu.acc_range) != 0) {
1082
-
VIVE_CONTROLLER_ERROR(
1083
-
d, "Could not get watchman IMU range packet!");
1069
+
VIVE_ERROR(d, "Could not get watchman IMU range packet!");
1084
1070
free(d);
1085
1071
return 0;
1086
1072
}
1087
1073
1088
-
VIVE_CONTROLLER_DEBUG(d, "Vive controller gyroscope range %f",
1089
-
d->imu.gyro_range);
1090
-
VIVE_CONTROLLER_DEBUG(d, "Vive controller accelerometer range %f",
1091
-
d->imu.acc_range);
1074
+
VIVE_DEBUG(d, "Vive controller gyroscope range %f",
1075
+
d->imu.gyro_range);
1076
+
VIVE_DEBUG(d, "Vive controller accelerometer range %f",
1077
+
d->imu.acc_range);
1092
1078
1093
1079
// successful config parsing determines d->variant
1094
1080
char *config = vive_read_config(d->controller_hid);
···
1096
1082
vive_config_parse_controller(d, config);
1097
1083
free(config);
1098
1084
} else {
1099
-
VIVE_CONTROLLER_ERROR(d,
1100
-
"Could not get Vive controller config\n");
1085
+
VIVE_ERROR(d, "Could not get Vive controller config\n");
1101
1086
free(d);
1102
1087
return 0;
1103
1088
}
···
1159
1144
d->base.update_inputs = _update_tracker_inputs;
1160
1145
} else {
1161
1146
d->base.name = XRT_DEVICE_GENERIC_HMD;
1162
-
VIVE_CONTROLLER_ERROR(d,
1163
-
"Failed to assign update input function");
1147
+
VIVE_ERROR(d, "Failed to assign update input function");
1164
1148
}
1165
1149
1166
1150
if (d->controller_hid) {
1167
1151
int ret = os_thread_helper_start(&d->controller_thread,
1168
1152
vive_controller_run_thread, d);
1169
1153
if (ret != 0) {
1170
-
VIVE_CONTROLLER_ERROR(
1171
-
d, "Failed to start mainboard thread!");
1154
+
VIVE_ERROR(d, "Failed to start mainboard thread!");
1172
1155
vive_controller_device_destroy((struct xrt_device *)d);
1173
1156
return 0;
1174
1157
}
1175
1158
}
1176
-
VIVE_CONTROLLER_DEBUG(d, "Opened vive controller!\n");
1159
+
VIVE_DEBUG(d, "Opened vive controller!\n");
1177
1160
1178
1161
return d;
1179
1162
}
+2
-27
src/xrt/drivers/vive/vive_controller.h
+2
-27
src/xrt/drivers/vive/vive_controller.h
···
16
16
#include "xrt/xrt_device.h"
17
17
#include "os/os_threading.h"
18
18
#include "math/m_imu_3dof.h"
19
+
#include "util/u_logging.h"
19
20
20
21
#ifdef __cplusplus
21
22
extern "C" {
···
81
82
82
83
struct xrt_quat rot_filtered;
83
84
84
-
bool print_spew;
85
-
bool print_debug;
85
+
enum u_logging_level ll;
86
86
87
87
uint32_t last_ticks;
88
88
···
135
135
#ifdef __cplusplus
136
136
}
137
137
#endif
138
-
139
-
#define VIVE_CONTROLLER_SPEW(p, ...) \
140
-
do { \
141
-
if (p->print_spew) { \
142
-
fprintf(stderr, "%s - ", __func__); \
143
-
fprintf(stderr, __VA_ARGS__); \
144
-
fprintf(stderr, "\n"); \
145
-
} \
146
-
} while (false)
147
-
148
-
#define VIVE_CONTROLLER_DEBUG(p, ...) \
149
-
do { \
150
-
if (p->print_debug) { \
151
-
fprintf(stderr, "%s - ", __func__); \
152
-
fprintf(stderr, __VA_ARGS__); \
153
-
fprintf(stderr, "\n"); \
154
-
} \
155
-
} while (false)
156
-
157
-
#define VIVE_CONTROLLER_ERROR(p, ...) \
158
-
do { \
159
-
fprintf(stderr, "%s - ", __func__); \
160
-
fprintf(stderr, __VA_ARGS__); \
161
-
fprintf(stderr, "\n"); \
162
-
} while (false)