HHD Omni::setup()
{
HDErrorInfo error;
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
// return -1;
}
printf("Omni Initialized\n");
/* Schedule the haptic callback function for continuously monitoring the
button state and rendering the anchored spring force. */
gCallbackHandle = hdScheduleAsynchronous(OmniForceCallback, 0, HD_MAX_SCHEDULER_PRIORITY);
hdEnable(HD_FORCE_OUTPUT);
/* Start the haptic rendering loop. */
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to start scheduler");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
// return -1;
}
return hHD;
}
void HapticDevice::init()
{
if(m_nbDevices>0)
{
HDErrorInfo error;
m_updateDeviceCallback = hdScheduleAsynchronous( aSchedule, &m_hss, HD_MAX_SCHEDULER_PRIORITY);
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
printf("Failed to start the scheduler\n");
}
else
{
printf("Succed to start the scheduler\n");
}
m_canLaunch = false;
m_posSet = false;
m_targetChoosen = false;
m_Feedback = true;
m_devine = true;
m_freeT =false;
m_impactPos = &m_effectors[0].getOrigin();
}
}
/******************************************************************************
Start the recording. Schedule a callback that records device data for
every scheduler tick.
******************************************************************************/
HDboolean hduRecorder::start()
{
HDSchedulerHandle h = hdScheduleAsynchronous(recordLoopCallback,
this,
HD_MIN_SCHEDULER_PRIORITY);
return (h == HD_INVALID_HANDLE ? false : true);
}
/*******************************************************************************
* main function
Initializes the device, creates a callback to handles plane forces,
terminates upon key press.
******************************************************************************/
int main(int argc, char* argv[])
{
HDErrorInfo error;
// Initialize the default haptic device.
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
// Start the servo scheduler and enable forces.
hdEnable(HD_FORCE_OUTPUT);
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to start the scheduler");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
// Schedule the frictionless plane callback, which will then run at
// servoloop rates and command forces if the user penetrates the plane.
HDCallbackCode hPlaneCallback = hdScheduleAsynchronous(
FrictionlessPlaneCallback, 0, HD_DEFAULT_SCHEDULER_PRIORITY);
printf("Plane example.\n");
printf("Move the device up and down to feel a plane along Y=0.\n");
printf("Push hard against the plane to popthrough to the other side.\n");
printf("Press any key to quit.\n\n");
while (!_kbhit())
{
if (!hdWaitForCompletion(hPlaneCallback, HD_WAIT_CHECK_STATUS))
{
fprintf(stderr, "\nThe main scheduler callback has exited\n");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
break;
}
}
// Cleanup and shutdown the haptic device, cleanup all callbacks.
hdStopScheduler();
hdUnschedule(hPlaneCallback);
hdDisableDevice(hHD);
return 0;
}
/*******************************************************************************
Initialize the HDAPI. This involves initing a device configuration, enabling
forces, and scheduling a haptic thread callback for servicing the device.
*******************************************************************************/
void initHL()
{
HDErrorInfo error;
ghHD = hdInitDevice( HD_DEFAULT_DEVICE );
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "Press any key to exit");
getchar();
exit(-1);
}
/*************************************************************
ADDED
*************************************************************/
hdScheduleAsynchronous(hdBeginCB, 0, HD_MAX_SCHEDULER_PRIORITY);
hdScheduleAsynchronous(hdEndCB, 0, HD_MIN_SCHEDULER_PRIORITY);
/*************************************************************
END ADDED
*************************************************************/
ghHLRC = hlCreateContext(ghHD);
hlMakeCurrent(ghHLRC);
// Enable optimization of the viewing parameters when rendering
// geometry for OpenHaptics.
hlEnable(HL_HAPTIC_CAMERA_VIEW);
// Generate id for the shape.
gShapeId = hlGenShapes(1);
gPointId = hlGenShapes(1);
hlTouchableFace(HL_FRONT);
hlAddEventCallback(HL_EVENT_TOUCH,gPointId , HL_COLLISION_THREAD,
hlTouchCB, 0);
hlAddEventCallback(HL_EVENT_UNTOUCH,gPointId , HL_COLLISION_THREAD,
hlUnTouchCB, 0);
}
/******************************************************************************
main function
Initializes the device, creates a callback to handle sphere forces, terminates
upon key press.
******************************************************************************/
int main(int argc, char* argv[])
{
HDErrorInfo error;
// Initialize the default haptic device.
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
// Start the servo scheduler and enable forces.
hdEnable(HD_FORCE_OUTPUT);
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to start scheduler");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
// Application loop - schedule our call to the main callback.
HDSchedulerHandle hSphereCallback = hdScheduleAsynchronous(
FrictionlessSphereCallback, 0, HD_DEFAULT_SCHEDULER_PRIORITY);
printf("Sphere example.\n");
printf("Move the device around to feel a frictionless sphere\n\n");
printf("Press any key to quit.\n\n");
while (!_kbhit())
{
if (!hdWaitForCompletion(hSphereCallback, HD_WAIT_CHECK_STATUS))
{
fprintf(stderr, "\nThe main scheduler callback has exited\n");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
break;
}
}
// For cleanup, unschedule our callbacks and stop the servo loop.
hdStopScheduler();
hdUnschedule(hSphereCallback);
hdDisableDevice(hHD);
return 0;
}
/******************************************************************************
Main function.
******************************************************************************/
int main(int argc, char* argv[])
{
HDErrorInfo error;
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
printf("Anchored Spring Force Example\n");
/* Schedule the haptic callback function for continuously monitoring the
button state and rendering the anchored spring force. */
gCallbackHandle = hdScheduleAsynchronous(
AnchoredSpringForceCallback, 0, HD_MAX_SCHEDULER_PRIORITY);
hdEnable(HD_FORCE_OUTPUT);
/* Query the max closed loop control stiffness that the device
can handle. Using a value beyond this limit will likely cause the
device to buzz. */
hdGetDoublev(HD_NOMINAL_MAX_STIFFNESS, &gMaxStiffness);
/* Start the haptic rendering loop. */
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to start scheduler");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
/* Start the main application loop. */
mainLoop();
/* Cleanup by stopping the haptics loop, unscheduling the asynchronous
callback, disabling the device. */
hdStopScheduler();
hdUnschedule(gCallbackHandle);
hdDisableDevice(hHD);
return 0;
}
//==========================================================================
void hdPhantomStartServo()
{
HDErrorInfo error;
if (!servoStarted)
{
// servo controller has been started
servoStarted = true;
// create callback
HDCallbackCode servoCallbackHandle = hdScheduleAsynchronous(
servoPhantomDevices, NULL, HD_DEFAULT_SCHEDULER_PRIORITY);
// start scheduler
hdStartScheduler();
}
}
/*******************************************************************************
Schedules the coulomb force callback.
*******************************************************************************/
void CoulombForceField()
{
gSchedulerCallback = hdScheduleAsynchronous(
CoulombCallback, 0, HD_DEFAULT_SCHEDULER_PRIORITY);
HDErrorInfo error;
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getchar();
exit(-1);
}
glutMainLoop(); // Enter GLUT main loop.
}
int main(int argc, char** argv) {
////////////////////////////////////////////////////////////////
// Init Phantom
////////////////////////////////////////////////////////////////
HDErrorInfo error;
HHD hHD;
hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError())) {
//hduPrintError(stderr, &error, "Failed to initialize haptic device");
ROS_ERROR("Failed to initialize haptic device"); //: %s", &error);
return -1;
}
ROS_INFO("Found %s.", hdGetString(HD_DEVICE_MODEL_TYPE));
hdEnable(HD_FORCE_OUTPUT);
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError())) {
ROS_ERROR("Failed to start the scheduler"); //, &error);
return -1;
}
HHD_Auto_Calibration();
////////////////////////////////////////////////////////////////
// Init ROS
////////////////////////////////////////////////////////////////
ros::init(argc, argv, "omni_haptic_node");
OmniState state;
PhantomROS omni_ros;
omni_ros.init(&state);
hdScheduleAsynchronous(omni_state_callback, &state,
HD_MAX_SCHEDULER_PRIORITY);
////////////////////////////////////////////////////////////////
// Loop and publish
////////////////////////////////////////////////////////////////
pthread_t publish_thread;
pthread_create(&publish_thread, NULL, ros_publish, (void*) &omni_ros);
pthread_join(publish_thread, NULL);
ROS_INFO("Ending Session....");
hdStopScheduler();
hdDisableDevice(hHD);
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
ghHD = HD_INVALID_HANDLE;
gSchedulerCallback = HD_INVALID_HANDLE;
bool returnValue = true;
int devideID = 0;
g_doExit = false;
//Initialize Haptic device
HDErrorInfo error;
// Initialize the device. This needs to be called before any actions on the
// device.
ghHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
returnValue = false;
hdEnable(HD_FORCE_OUTPUT);
hdEnable(HD_MAX_FORCE_CLAMPING);
// Initialize amplitude for move vribration
hdGetDoublev(HD_NOMINAL_MAX_CONTINUOUS_FORCE, &gVibrationAmplitude);
gVibrationAmplitude *= 0.75;
gSchedulerCallback = hdScheduleAsynchronous(touchScene, 0,
HD_MAX_SCHEDULER_PRIORITY);
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
returnValue = false;
atexit(ExitHandler);
while(!g_doExit){
//printf("%i %i %i\n",g_button1,g_button2,g_button3);
}
return 0;
}
/*******************************************************************************
Main function.
Sets up the device, runs main application loop, cleans up when finished.
*******************************************************************************/
int main(int argc, char* argv[])
{
HDSchedulerHandle hUpdateHandle = 0;
HDErrorInfo error;
/* Initialize the device, must be done before attempting to call any hd
functions. */
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize the device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
/* Schedule the main scheduler callback that updates the device state. */
hUpdateHandle = hdScheduleAsynchronous(
updateDeviceCallback, 0, HD_MAX_SCHEDULER_PRIORITY);
/* Start the servo loop scheduler. */
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to start the scheduler");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
/* Run the application loop. */
mainLoop();
/* For cleanup, unschedule callbacks and stop the servo loop. */
hdStopScheduler();
hdUnschedule(hUpdateHandle);
hdDisableDevice(hHD);
return 0;
}
bool BaseGeometryPatch::setup()
{
/* Initialize the device, must be done before attempting to call any hd
functions. Passing in HD_DEFAULT_DEVICE causes the default device to be
initialized. */
hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return false;
}
printf("Hello Haptic Device!\n");
printf("Found device model: %s.\n\n", hdGetString(HD_DEVICE_MODEL_TYPE));
/* Schedule the main callback that will render forceVecs to the device. */
hHapticEffect = hdScheduleAsynchronous(patchCallback, this, HD_DEFAULT_SCHEDULER_PRIORITY);
return true;
}
int main(int argc, char ** argv)
{
//Init Phantom
phantomOpen();
printf("Phantom Opened \n");
//Init ROS
ros::init(argc, argv , "phantom_slave");
ros::NodeHandle nh;
data= fopen("data.txt","w");
// Publisher
Mas2Sla_pub = nh.advertise<geometry_msgs::PointStamped>("/MasToSla",1);
Mas2SlaEnergy_pub = nh.advertise<geometry_msgs::PointStamped>("/MasToSlaEnergy",1);
//Subcriber
ros::Subscriber SlaToMasVs_sub = nh.subscribe<geometry_msgs::PointStamped>("/SlatoMasVs", 1,SlaToMasVsDelay);
ros::Subscriber SlaToMasFe_sub = nh.subscribe<geometry_msgs::PointStamped>("/SlatoMasFe", 1,SlaToMasFeDelay);
ros::Subscriber SlaToMasFv_sub = nh.subscribe<geometry_msgs::PointStamped>("/SlatoMasFv", 1,SlaToMasFvDelay);
//Asign callback
hPhantomMain = hdScheduleAsynchronous(phantom_callback, 0, HD_MAX_SCHEDULER_PRIORITY);
// hdSetSchedulerRate(1000);
init_Data();
//Start Phantom Scheduler
phantomRun();
//waiting
while(ros::ok() && nh.ok())
{
ros::spinOnce();
}
phantomClose();
return 1;
}
/*******************************************************************************
Main function.
Initializes the device, starts the schedule, creates a schedule callback
to handle gravity well forces, waits for the user to press a button, exits
the application.
*******************************************************************************/
int main(int argc, char* argv[])
{
int KeyInfo;
HDErrorInfo error;
HDSchedulerHandle hGravityWell;
/* Initialize the device, must be done before attempting to call any hd
functions. Passing in HD_DEFAULT_DEVICE causes the default device to be
initialized. */
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
hIOMutex = CreateMutex(NULL, FALSE, NULL);
kill = 0;
recording = 0;
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
printf("Hello Haptic Device!\n");
printf("Found device model: %s.\n\n", hdGetString(HD_DEVICE_MODEL_TYPE));
/* Schedule the main callback that will render forces to the device. */
hGravityWell = hdScheduleAsynchronous(
gravityWellCallback, 0,
HD_MAX_SCHEDULER_PRIORITY);
hdEnable(HD_FORCE_OUTPUT);
hdStartScheduler();
_beginthread( recordingLoop );
/* Check for errors and abort if so. */
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to start scheduler");
fprintf(stderr, "\nPress any key to quit.\n");
return -1;
}
/* Wait until the user presses a key. Meanwhile, the scheduler
runs and applies forces to the device. */
printf("Press R to record data\n");
printf("Press Q to quit.\n\n");
count = 0;
//while (!_kbhit())
do
{
KeyInfo = _getch();
if ( tolower( KeyInfo ) == 'q')
{
kill = 1;
}
else
{
if ( tolower( KeyInfo ) == 'r' )
{
if ( recording == 0) {
printf("Data recording ON\n");
recording = 1;
}
else
{
printf("Data recording OFF\n");
recording = 0;
}
}
}
/* Periodically check if the gravity well callback has exited. */
if (!hdWaitForCompletion(hGravityWell, HD_WAIT_CHECK_STATUS))
{
kill = 1;
fprintf(stderr, "Press any key to quit.\n");
getch();
break;
}
// printf("\n%d", count);
} while (!kill);
/* For cleanup, unschedule callback and stop the scheduler. */
hdStopScheduler();
hdUnschedule(hGravityWell);
/* Disable the device. */
hdDisableDevice(hHD);
return 0;
}
void Window::initializeGL()
{
initializeOpenGLFunctions();
connect(context(), SIGNAL(aboutToBeDestroyed()), this, SLOT(teardownGL()), Qt::DirectConnection);
printVersionInformation();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
//Loading, compiling and linking shaders.
shaderProgram = new QOpenGLShaderProgram();
shaderProgram->addShaderFromSourceFile(QOpenGLShader::Vertex, ".\\simple.vert");
shaderProgram->addShaderFromSourceFile(QOpenGLShader::Fragment, ".\\simple.frag");
shaderProgram->link();
shaderProgram->bind();
//Creating the VAO
vertexArrayObject.create();
vertexArrayObject.bind();
//We now need to combine the data of out mesh and our interator mesh
vector<Vertex> combinedVertexBuffer;
combinedVertexBuffer.reserve(mesh->getVertexVector().size() +
interatorMesh->getVertexVector().size());
combinedVertexBuffer.insert(combinedVertexBuffer.end(), mesh->
getVertexVector().begin(), mesh->getVertexVector().end());
combinedVertexBuffer.insert(combinedVertexBuffer.end(), interatorMesh->
getVertexVector().begin(), interatorMesh->getVertexVector().end());
//Index buffer
vector<unsigned int> combinedIndexBuffer;
combinedIndexBuffer.reserve(mesh->getIndexVector().size() + interatorMesh->
getIndexVector().size());
combinedIndexBuffer.insert(combinedIndexBuffer.end(), mesh->
getIndexVector().begin(), mesh->getIndexVector().end());
unsigned int vertexVectorSize = static_cast<unsigned int>(mesh->
getVertexVector().size());
for (auto index : interatorMesh->getIndexVector()) {
combinedIndexBuffer.push_back(index + vertexVectorSize);
}
//Creating the VBO for the mesh
vertexBuffer.create();
vertexBuffer.bind();
vertexBuffer.setUsagePattern(QOpenGLBuffer::DynamicDraw);
vertexBuffer.allocate(combinedVertexBuffer.data(),
static_cast<int>(combinedVertexBuffer.size() * sizeof(Vertex)));
//Creating IBO for the mesh
indexBuffer = QOpenGLBuffer(QOpenGLBuffer::IndexBuffer);
indexBuffer.create();
indexBuffer.bind();
indexBuffer.setUsagePattern(QOpenGLBuffer::DynamicDraw);
indexBuffer.allocate(combinedIndexBuffer.data(),
static_cast<int>(combinedIndexBuffer.size() * sizeof(unsigned int)));
//Enabling attribute arrays for vertex, normal and color data.
shaderProgram->enableAttributeArray(0);
shaderProgram->enableAttributeArray(1);
shaderProgram->enableAttributeArray(2);
shaderProgram->setAttributeBuffer(0, GL_FLOAT, Vertex::positionOffset(), Vertex::PositionTupleSize, Vertex::stride());
shaderProgram->setAttributeBuffer(1, GL_FLOAT, Vertex::colorOffset(), Vertex::ColorTupleSize, Vertex::stride());
shaderProgram->setAttributeBuffer(2, GL_FLOAT, Vertex::normalOffset(), Vertex::NormalTupleSize, Vertex::stride());
vertexArrayObject.release();
vertexBuffer.release();
indexBuffer.release();
shaderProgram->release();
//Setting up model, view and projection matrices.
mvpSetup();
//Creating interator ray
interator = new Ray(vec3(0.0f, 0.0f, 0.0f), vec3(0.0f, 0.0f, 1.0f));
//Setting up the collision detector
collisionDetector.setMesh(mesh);
collisionDetector.setRay(interator);
//Initializing haptic device
if (hapticsEnabled) {
haptic.initializeHL();
haptic.updateHapticWorkspace();
haptic.setInterator(interator);
haptic.setCollisionDetector(&collisionDetector);
haptic.setCollisionPath(&path);
haptic.setMesh(mesh);
haptic.setShaderProgram(shaderProgram);
haptic.setVAO(&vertexArrayObject);
handle = hdScheduleAsynchronous(HapticInterface::mainHapticCallback,
&haptic, HD_MAX_SCHEDULER_PRIORITY);
hdStartScheduler();
}
}
/******************************************************************************
Collects statistics about the update rate of the haptic device.
******************************************************************************/
int main(int argc, char* argv[])
{
HDErrorInfo error;
HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
hduPrintError(stderr, &error, "Failed to initialize haptic device");
fprintf(stderr, "\nPress any key to quit.\n");
getch();
return -1;
}
HDstring model = hdGetString(HD_DEVICE_MODEL_TYPE);
std::cout << "Initialized: " << model << std::endl;
HDSchedulerHandle hServoCallback = hdScheduleAsynchronous(
ServoSchedulerCallback, 0, HD_MAX_SCHEDULER_PRIORITY);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
std::cerr << error << std::endl;
std::cerr << "Failed to schedule servoloop callback" << std::endl;
hdDisableDevice(hHD);
return -1;
}
hdSetSchedulerRate(TARGET_SERVOLOOP_RATE);
if (HD_DEVICE_ERROR(error = hdGetError()))
{
std::cerr << error << std::endl;
std::cerr << "Failed to set servoloop rate" << std::endl;
hdDisableDevice(hHD);
return -1;
}
hdDisable(HD_FORCE_OUTPUT);
hdStartScheduler();
if (HD_DEVICE_ERROR(error = hdGetError()))
{
std::cerr << error << std::endl;
std::cerr << "Failed to start servoloop" << std::endl;
hdDisableDevice(hHD);
return -1;
}
std::cout << "Printing servoloop rate stats. All numbers are in Hz units" << std::endl;
std::cout << std::endl;
char fileName[256];
sprintf(fileName, "%s Rate Stats.txt", model);
std::ofstream fout(fileName, std::ios::out | std::ios::app);
for (int nRuns = 0; nRuns < 10 && !_kbhit(); nRuns++)
{
Sleep(1000);
hdScheduleSynchronous(CopyUpdateRateStats, 0, HD_MIN_SCHEDULER_PRIORITY);
// Prints some stats about the rate as well as log it to file.
PrintUpdateRateStats(std::cout);
PrintUpdateRateStats(fout);
if (!hdWaitForCompletion(hServoCallback, HD_WAIT_CHECK_STATUS))
{
std::cerr << "Error occurred during main loop" << std::endl;
std::cerr << "Press any key to quit." << std::endl;
getch();
break;
}
}
hdStopScheduler();
hdUnschedule(hServoCallback);
hdDisableDevice(hHD);
return 0;
}
void CybPhantom::setGuided(bool guided) {
this->guided = guided;
hdScheduleAsynchronous(setForce, NULL, HD_DEFAULT_SCHEDULER_PRIORITY);
}
