int pair(const char *custom_addr)
{
if (!psmove_init(PSMOVE_CURRENT_VERSION)) {
fprintf(stderr, "PS Move API init failed (wrong version?)\n");
exit(1);
}
int count = psmove_count_connected();
int i;
PSMove *move;
int result = 0;
printf("Connected controllers: %d\n", count);
for (i=0; i<count; i++) {
move = psmove_connect_by_id(i);
if (move == NULL) {
printf("Error connecting to PSMove #%d\n", i+1);
result = 1;
continue;
}
if (psmove_connection_type(move) != Conn_Bluetooth) {
printf("PSMove #%d connected via USB.\n", i+1);
int result = 0;
if (custom_addr != NULL) {
result = psmove_pair_custom(move, custom_addr);
} else {
result = psmove_pair(move);
}
if (result) {
printf("Pairing of #%d succeeded!\n", i+1);
char *serial = psmove_get_serial(move);
printf("Controller address: %s\n", serial);
free(serial);
} else {
printf("Pairing of #%d failed.\n", i+1);
}
if (psmove_has_calibration(move)) {
printf("Calibration data available and saved.\n");
} else {
printf("Error reading/loading calibration data.\n");
}
} else {
printf("Ignoring non-USB PSMove #%d\n", i+1);
}
psmove_disconnect(move);
}
psmove_shutdown();
return result;
}
int main(int argc, char* argv[])
{
PSMove *move;
int i, c;
if (!psmove_init(PSMOVE_CURRENT_VERSION)) {
fprintf(stderr, "PS Move API init failed (wrong version?)\n");
exit(1);
}
c = psmove_count_connected();
printf("Connected controllers: %d\n", c);
for (i=0; i<c; i++) {
move = psmove_connect_by_id(i);
switch (i) {
case 0:
psmove_set_leds(move, 255, 0, 0);
break;
case 1:
psmove_set_leds(move, 0, 255, 0);
break;
case 2:
psmove_set_leds(move, 0, 0, 255);
break;
case 3:
psmove_set_leds(move, 255, 255, 0);
break;
case 4:
psmove_set_leds(move, 0, 255, 255);
break;
case 5:
psmove_set_leds(move, 255, 0, 255);
break;
default:
psmove_set_leds(move, 255, 255, 255);
break;
}
psmove_update_leds(move);
psmove_disconnect(move);
}
psmove_shutdown();
return 0;
}
int main(int argc, char* argv[])
{
if (!psmove_init(PSMOVE_CURRENT_VERSION)) {
fprintf(stderr, "PS Move API init failed (wrong version?)\n");
exit(1);
}
PSMove *move = psmove_connect();
if (move == NULL) {
printf("Could not connect to default Move controller.\n"
"Please connect one via Bluetooth.\n");
exit(1);
}
csv = psmove_file_open("read_performance.csv", "w");
assert(csv != NULL);
fprintf(csv, "mode,time,reads,dropped\n");
printf("\n -- PS Move API Sensor Reading Performance Test -- \n");
printf("\nTesting STATIC READ performance (non-changing LED setting)\n");
test_read_performance(move, STATIC_UPDATES);
printf("\nTesting SMART READ performance (rate-limited LED setting)\n");
test_read_performance(move, SMART_UPDATES);
printf("\nTesting BAD READ performance (continous LED setting)\n");
test_read_performance(move, ALL_UPDATES);
printf("\nTesting RAW READ performance (no LED setting)\n");
test_read_performance(move, NO_UPDATES);
printf("\n");
psmove_file_close(csv);
psmove_shutdown();
return 0;
}
int
main(int argc, char* argv[])
{
PSMove *move;
if (!psmove_init(PSMOVE_CURRENT_VERSION)) {
fprintf(stderr, "PS Move API init failed (wrong version?)\n");
exit(1);
}
move = psmove_connect();
if (move == NULL) {
fprintf(stderr, "Could not connect to controller.\n");
return EXIT_FAILURE;
}
assert(psmove_has_calibration(move));
if (psmove_connection_type(move) == Conn_Bluetooth) {
float ax, ay, az, gx, gy, gz;
while (1) {
int res = psmove_poll(move);
if (res) {
psmove_get_accelerometer_frame(move, Frame_SecondHalf,
&ax, &ay, &az);
psmove_get_gyroscope_frame(move, Frame_SecondHalf,
&gx, &gy, &gz);
printf("A: %5.2f %5.2f %5.2f ", ax, ay, az);
printf("G: %6.2f %6.2f %6.2f ", gx, gy, gz);
printf("\n");
}
}
}
psmove_disconnect(move);
psmove_shutdown();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
if (!psmove_init(PSMOVE_CURRENT_VERSION)) {
fprintf(stderr, "PS Move API init failed (wrong version?)\n");
exit(1);
}
/* Check if at least one controller is attached */
if (psmove_count_connected() < 1) {
printf("No Move controller attached.\n");
exit(1);
}
PSMove *move = psmove_connect();
if(move == NULL) {
printf("Could not connect to default Move controller.\n");
exit(1);
}
/* Make sure we are connected via Bluetooth */
if (psmove_connection_type(move) != Conn_Bluetooth) {
printf("Controller must be connected via Bluetooth.\n");
psmove_disconnect(move);
exit(1);
}
unsigned int freq_idx = 0;
while (!(psmove_get_buttons(move) & Btn_PS)) {
if (!psmove_poll(move)) {
continue;
}
unsigned int pressed_buttons;
psmove_get_button_events(move, &pressed_buttons, NULL);
unsigned long frequency = freqs[freq_idx];
/* Cycle through the list of frequencies */
if (pressed_buttons & Btn_CROSS) {
freq_idx = (freq_idx + 1) % NUM_FREQS;
frequency = freqs[freq_idx];
printf("Selecting frequency %lu Hz. Press SQUARE to apply.\n", frequency);
}
/* Apply the currently selected frequency as new PWM frequency */
if (pressed_buttons & Btn_SQUARE) {
printf("Setting LED PWM frequency to %lu Hz.\n", frequency);
/*
Switch off the LEDs. If we do not do this, changing the PWM
frequency will switch off the LEDs and keep them off until
the Bluetooth connection has been teared down (at least
once) and then reestablished.
*/
psmove_set_leds(move, 0, 0, 0);
psmove_update_leds(move);
/*
TODO:
How can we make sure the LEDs are really off before changing
the PWM frequency? It seems to work in all tests so far, but
a proper verification would be nice.
*/
if (!psmove_set_led_pwm_frequency(move, frequency)) {
printf("Failed to set LED PWM frequency.\n");
}
}
/* Keep fixed color for visual feedback */
psmove_set_leds(move, 0, 0, 63);
psmove_update_leds(move);
}
psmove_disconnect(move);
psmove_shutdown();
return 0;
}
int main(int argc, char* argv[])
{
PSMove *move;
enum PSMove_Connection_Type ctype;
int i;
if (!psmove_init(PSMOVE_CURRENT_VERSION)) {
fprintf(stderr, "PS Move API init failed (wrong version?)\n");
exit(1);
}
i = psmove_count_connected();
printf("Connected controllers: %d\n", i);
move = psmove_connect();
if (move == NULL) {
printf("Could not connect to default Move controller.\n"
"Please connect one via USB or Bluetooth.\n");
exit(1);
}
char *serial = psmove_get_serial(move);
printf("Serial: %s\n", serial);
free(serial);
ctype = psmove_connection_type(move);
switch (ctype) {
case Conn_USB:
printf("Connected via USB.\n");
break;
case Conn_Bluetooth:
printf("Connected via Bluetooth.\n");
break;
case Conn_Unknown:
printf("Unknown connection type.\n");
break;
}
for (i=0; i<10; i++) {
psmove_set_leds(move, 0, 255*(i%3==0), 0);
psmove_set_rumble(move, 255*(i%2));
psmove_update_leds(move);
psmove_usleep(10000 * (i % 10));
}
for (i=250; i>=0; i-=5) {
psmove_set_leds(move, i, i, 0);
psmove_set_rumble(move, 0);
psmove_update_leds(move);
}
/* Enable rate limiting for LED updates */
psmove_set_rate_limiting(move, 1);
psmove_set_leds(move, 0, 0, 0);
psmove_set_rumble(move, 0);
psmove_update_leds(move);
while (ctype != Conn_USB && !(psmove_get_buttons(move) & Btn_PS)) {
int res = psmove_poll(move);
if (res) {
if (psmove_get_buttons(move) & Btn_TRIANGLE) {
printf("Triangle pressed, with trigger value: %d\n",
psmove_get_trigger(move));
psmove_set_rumble(move, psmove_get_trigger(move));
} else {
psmove_set_rumble(move, 0x00);
}
psmove_set_leds(move, 0, 0, psmove_get_trigger(move));
int x, y, z;
psmove_get_accelerometer(move, &x, &y, &z);
printf("accel: %5d %5d %5d\n", x, y, z);
psmove_get_gyroscope(move, &x, &y, &z);
printf("gyro: %5d %5d %5d\n", x, y, z);
psmove_get_magnetometer(move, &x, &y, &z);
printf("magnetometer: %5d %5d %5d\n", x, y, z);
printf("buttons: %x\n", psmove_get_buttons(move));
int battery = psmove_get_battery(move);
if (battery == Batt_CHARGING) {
printf("battery charging\n");
} else if (battery == Batt_CHARGING_DONE) {
printf("battery fully charged (on charger)\n");
} else if (battery >= Batt_MIN && battery <= Batt_MAX) {
printf("battery level: %d / %d\n", battery, Batt_MAX);
} else {
printf("battery level: unknown (%x)\n", battery);
}
printf("raw temperature: %d\n", psmove_get_temperature(move));
printf("celsius temperature: %f\n", psmove_get_temperature_in_celsius(move));
psmove_update_leds(move);
}
}
psmove_disconnect(move);
psmove_shutdown();
return 0;
}
uint32 FPSMoveWorker::Run()
{
if (!psmove_init(PSMOVE_CURRENT_VERSION))
{
UE_LOG(LogPSMove, Error, TEXT("PS Move API init failed (wrong version?)"));
return -1;
}
// I want the psmoves and psmove_tracker to be local variables in the thread.
// Initialize an empty array of psmove controllers
PSMove* psmoves[FPSMoveWorker::k_max_controllers];
memset(psmoves, 0, sizeof(psmoves));
// Initialize and configure the psmove_tracker
PSMoveTracker *psmove_tracker = psmove_tracker_new(); // Unfortunately the API does not have a way to change the resolution and framerate.
PSMoveFusion *psmove_fusion = psmove_fusion_new(psmove_tracker, 1., 1000.);
int tracker_width = 640;
int tracker_height = 480;
if (psmove_tracker)
{
UE_LOG(LogPSMove, Log, TEXT("PSMove tracker initialized."));
//Set exposure. TODO: Expose this to component.
psmove_tracker_set_exposure(psmove_tracker, Exposure_LOW); //Exposure_LOW, Exposure_MEDIUM, Exposure_HIGH
psmove_tracker_set_smoothing(psmove_tracker, 0, 1);
psmove_tracker_set_mirror(psmove_tracker, PSMove_True);
psmove_tracker_get_size(psmove_tracker, &tracker_width, &tracker_height);
UE_LOG(LogPSMove, Log, TEXT("Camera Dimensions: %d x %d"), tracker_width, tracker_height);
}
else {
UE_LOG(LogPSMove, Log, TEXT("PSMove tracker failed to initialize."));
}
//Initial wait before starting.
FPlatformProcess::Sleep(0.03);
float xcm, ycm, zcm, oriw, orix, oriy, oriz;
while (StopTaskCounter.GetValue() == 0)
{
// Get positional data from tracker
if (psmove_tracker)
{
// Setup or tear down controller connections based on the number of active controllers
UpdateControllerConnections(psmove_tracker, psmoves);
// Renew the image on camera
if (PSMoveCount > 0)
{
psmove_tracker_update_image(psmove_tracker); // Sometimes libusb crashes here.
psmove_tracker_update_cbb(psmove_tracker, NULL); // Passing null (instead of m_moves[i]) updates all controllers.
}
}
else {
FPlatformProcess::Sleep(0.001);
}
for (int i = 0; i < PSMoveCount; i++)
{
FPSMoveRawControllerData_TLS &localControllerData = WorkerControllerDataArray[i];
//--------------
// Read the published data from the component
//--------------
localControllerData.WorkerRead();
// Get positional data from tracker
if (psmove_tracker)
{
localControllerData.IsTracked = psmove_tracker_get_status(psmove_tracker, psmoves[i]) == Tracker_TRACKING;
psmove_fusion_get_transformed_location(psmove_fusion, psmoves[i], &xcm, &ycm, &zcm);
if (localControllerData.IsTracked &&
xcm && ycm && zcm &&
!isnan(xcm) && !isnan(ycm) && !isnan(zcm) &&
xcm == xcm && ycm == ycm && zcm == zcm)
{
localControllerData.PosX = xcm;
localControllerData.PosY = ycm;
localControllerData.PosZ = zcm;
}
else {
localControllerData.IsTracked = false;
}
//UE_LOG(LogPSMove, Log, TEXT("X: %f, Y: %f, Z: %f"), xcm, ycm, zcm);
if (localControllerData.ResetPoseRequest && localControllerData.IsTracked)
{
psmove_tracker_reset_location(psmove_tracker, psmoves[i]);
}
// If we are to change the tracked colour.
if (localControllerData.UpdateLedRequest)
{
// Stop tracking the controller with the existing color
psmove_tracker_disable(psmove_tracker, psmoves[i]);
localControllerData.IsTracked = false;
localControllerData.IsCalibrated = false;
psmove_tracker_set_dimming(psmove_tracker, 0.0); // Set dimming to 0 to trigger blinking calibration.
psmove_set_leds(psmoves[i], 0, 0, 0); // Turn off the LED to make sure it isn't trackable until new colour set.
psmove_update_leds(psmoves[i]);
FColor newFColor = localControllerData.LedColourRequest.Quantize();
if (psmove_tracker_enable_with_color(psmove_tracker, psmoves[i], newFColor.R, newFColor.G, newFColor.B) == Tracker_CALIBRATED)
{
this->WorkerControllerDataArray[i].IsCalibrated = true;
}
else
{
UE_LOG(LogPSMove, Error, TEXT("Failed to change tracking color for PSMove controller %d"), i);
}
localControllerData.LedColourWasUpdated = true;
}
else
{
localControllerData.LedColourWasUpdated = false;
}
}
else {
FPlatformProcess::Sleep(0.001);
}
// Do bluetooth IO: Orientation, Buttons, Rumble
//TODO: Is it necessary to keep polling until no frames are left?
while (psmove_poll(psmoves[i]) > 0)
{
// Update the controller status (via bluetooth)
psmove_poll(psmoves[i]);
// Get the controller orientation (uses IMU).
psmove_get_orientation(psmoves[i],
&oriw, &orix, &oriy, &oriz);
localControllerData.OriW = oriw;
localControllerData.OriX = orix;
localControllerData.OriY = oriy;
localControllerData.OriZ = oriz;
//UE_LOG(LogPSMove, Log, TEXT("Ori w,x,y,z: %f, %f, %f, %f"), oriw, orix, oriy, oriz);
// Get the controller button state
localControllerData.Buttons = psmove_get_buttons(psmoves[i]); // Bitwise; tells if each button is down.
psmove_get_button_events(psmoves[i], &localControllerData.Pressed, &localControllerData.Released); // i.e., state change
// Get the controller trigger value (uint8; 0-255)
localControllerData.TriggerValue = psmove_get_trigger(psmoves[i]);
// Set the controller rumble (uint8; 0-255)
psmove_set_rumble(psmoves[i], localControllerData.RumbleRequest);
}
if (localControllerData.ResetPoseRequest)
{
psmove_reset_orientation(psmoves[i]);
//TODO: reset yaw only
localControllerData.PoseWasReset = true;
}
else {
localControllerData.PoseWasReset = false;
}
//--------------
// Publish the updated worker data to the component
//--------------
localControllerData.WorkerPost();
}
//Sleeping the thread seems to crash libusb.
//FPlatformProcess::Sleep(0.005);
}
// Delete the controllers
for (int i = 0; i<PSMoveCount; i++)
{
psmove_disconnect(psmoves[i]);
}
// Delete the fusion
if (psmove_fusion)
{
psmove_fusion_free(psmove_fusion);
}
// Delete the tracker
if (psmove_tracker)
{
psmove_tracker_free(psmove_tracker);
}
psmove_shutdown();
return 0;
}
