SensAble Technologies(已被3Dsystems收购)公司是3D可触摸（力反馈）解决方案和技术领域中的领先开发商，其解决方案和技术不仅使用户能够看到并听到屏幕计算机应用，还可以对该应用进行实际“感应”。该公司的PHANTOM系列触觉与力反馈交互设备能使用户接触并操作虚拟物体。其触觉技术广泛应用于诸多领域，包括外科手术模拟、牙科整形、虚拟装配与虚拟维修、3D 设计（艺术和雕塑），以及机器人遥操作等领域。

使用官方提供的OpenHaptics Toolkit可以方便的编写基于Phantom触觉力反馈设备的应用程序。OpenHaptics工具包包括QuickHaptics Micro API、Haptic Device API（HDAPI）、Haptic Library API （HLAPI）、PHANTOM Device Drivers（PDD）、实用工具和源代码示例。最底层的是PDD设备驱动程序，它支持公司所有系列的力反馈设备；HDAPI提供了一个底层接口，通过它能直接产生反馈力以及获取设备的状态信息；HLAPI则为熟悉OpenGL的编程人员提供了一个上层接口。

下面来搭建OpenHaptics的编程环境（Win7 64位系统 + VS2013 + OpenHaptics 3.4.0），先在这里下载设备驱动程序和OpenHaptics Toolkit。参考安装手册连接好电脑和Phantom设备后可以打开官方自带的Phantom Test程序进行测试，验证设备是否连接成功。

接下来使用HDAPI创建一个力反馈应用程序（以examples\HD\console\HelloHapticDevice为例），程序基本流程如下：

　　1.  Initialize the device.

　　2.  Create a scheduler callback.

　　3.  Enable device forces.

　　4.  Start the scheduler.

　　5.  Cleanup the device and scheduler when the application is terminated. 

参考下面的程序结构图，为了实现流畅稳定的触觉力反馈，创建的任务将以1000Hz的频率运行在优先级高的线程中（The scheduler manages a high frequency, high priority thread for sending forces and retrieving state information from the device. Typically, force updates need to be sent at 1000 Hz frequency in order to create compelling and stable force feedback）：

下面配置VS工程：

1）设置头文件包含目录（Set the correct include path, as shown below in “Additional Include Directories.”）

Examples for setting include paths:

$(OH_SDK_BASE)\include                     Main include directory for the HD library.
$(OH_SDK_BASE)\utilities\include         Include directory for utilities.

2）添加库文件（Add the appropriate library modules as shown below in “Additional Dependencies”）

3）设置附加库目录（Make sure the linker paths are set correctly on the “Additional Library Directories” line so that the library fles can be found whenyour application links）

As for the header fle include paths, the library directories will use the OH_SDK_BASE environment variable. In general VisualStudio will automatically set the PlatformName to be one of Win32 or x64 and the ConfgurationName to be either Release or Debug. 

配置好工程属性后就可以点击生成按钮，不过生成过程中出现了“error LNK2019：无法解析的外部符号”这种错误（很多人遇到过这个问题）：

在网上搜索解决方案，3DSystems Haptics Forums上有一种办法是将utilities中的lib文件重新编译一遍，源文件就在utilities/src中：

使用VS013重新生成Win32、x64平台下的Debug和Release版本的lib，然后将原先的替换掉，再进行编译就OK了。

下面看看HelloHapticDevice的代码：

1. /*****************************************************************************  
2. Description:   
3.  
4.   This application creates a gravity well, which will attract  
5.   the device towards its center when the device enters its proximity.    
6. *******************************************************************************/ 
7.  
8. #include <stdio.h>  
9. #include <string.h>  
10. #include <conio.h>  
11.  
12. #include <HD/hd.h>  
13. #include <HDU/hduError.h>  
14. #include <HDU/hduVector.h>  
15.  
16. HDCallbackCode HDCALLBACK gravityWellCallback(void *data);  
17.  
18.  
19. /*******************************************************************************
20.  Main function.  
21.  Initializes the device, starts the schedule, creates a schedule callback  
22.  to handle gravity well forces, waits for the user to press a button, exits  
23.  the application.  
24. *******************************************************************************/ 
25. int main(int argc, char* argv[])  
26. {      
27.     HDErrorInfo error;  
28.     HDSchedulerHandle hGravityWell;  
29.  
30.     /* Initialize the device, must be done before attempting to call any hd 
31.        functions. Passing in HD_DEFAULT_DEVICE causes the default device to be   
32.        initialized. */ 
33.     HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);  
34.     if (HD_DEVICE_ERROR(error = hdGetError()))   
35.     {  
36.         hduPrintError(stderr, &error, "Failed to initialize haptic device");  
37.         fprintf(stderr, "\nPress any key to quit.\n");  
38.         return -1;  
39.     }  
40.  
41.     printf("Hello Haptic Device!\n");  
42.     printf("Found device model: %s.\n\n", hdGetString(HD_DEVICE_MODEL_TYPE));  
43.  
44.     /* Schedule the main callback that will render forces to the device. */ 
45.     hGravityWell = hdScheduleAsynchronous(gravityWellCallback, 0, HD_MAX_SCHEDULER_PRIORITY);  
46.  
47.     hdEnable(HD_FORCE_OUTPUT);  
48.     hdStartScheduler();  
49.  
50.     /* Check for errors and abort if so. */ 
51.     if (HD_DEVICE_ERROR(error = hdGetError()))  
52.     {  
53.         hduPrintError(stderr, &error, "Failed to start scheduler");  
54.         fprintf(stderr, "\nPress any key to quit.\n");  
55.         return -1;  
56.     }  
57.  
58.     /* Wait until the user presses a key.  Meanwhile, the scheduler
59.     runs and applies forces to the device. */ 
60.     printf("Feel around for the gravity well...\n");  
61.     printf("Press any key to quit.\n\n");  
62.     while (!kbhit())  
63.     {  
64.         /* Periodically check if the gravity well callback has exited. */ 
65.         if (!hdWaitForCompletion(hGravityWell, HD_WAIT_CHECK_STATUS))  // Checks if a callback is still scheduled for execution.  
66.         {  
67.             fprintf(stderr, "Press any key to quit.\n");       
68.             break;  
69.         }  
70.     }  
71.  
72.     /* For cleanup, unschedule callback and stop the scheduler. */ 
73.     hdStopScheduler();          // Typically call this as a frst step for cleanup and shutdown of devices  
74.     hdUnschedule(hGravityWell); // removing the associated callback from the scheduler.  
75.     hdDisableDevice(hHD);       // Disables a device. The handle should not be used afterward  
76.  
77.     return 0;  
78. }  
79.  
80.  
81.  
82. /*******************************************************************************
83.  Servo callback.    
84.  Called every servo loop tick.  Simulates a gravity well, which sucks the device   
85.  towards its center whenever the device is within a certain range.  
86. *******************************************************************************/ 
87. HDCallbackCode HDCALLBACK gravityWellCallback(void *data)  
88. {  
89.     const HDdouble kStiffness = 0.075; /* N/mm */ 
90.     const HDdouble kGravityWellInfluence = 40; /* mm */ 
91.  
92.     /* This is the position of the gravity well in cartesian(i.e. x,y,z) space. */ 
93.     static const hduVector3Dd wellPos = {0,0,0};  
94.  
95.     HDErrorInfo error;  
96.     hduVector3Dd position;  
97.     hduVector3Dd force;  
98.     hduVector3Dd positionTwell;  
99.  
100.     HHD hHD = hdGetCurrentDevice();  // Gets the handle of the current device  
101.  
102.     /* Begin haptics frame.  ( In general, all state-related haptics calls
103.        should be made within a frame. ) */ 
104.     hdBeginFrame(hHD);  
105.  
106.     /* Get the current position of the device. */ 
107.     hdGetDoublev(HD_CURRENT_POSITION, position);  
108.       
109.     memset(force, 0, sizeof(hduVector3Dd));  
110.       
111.     /* >  positionTwell = wellPos-position  < 
112.        Create a vector from the device position towards the gravity   
113.        well's center. */ 
114.     hduVecSubtract(positionTwell, wellPos, position);  
115.       
116.     /* If the device position is within some distance of the gravity well's 
117.        center, apply a spring force towards gravity well's center.  The force  
118.        calculation differs from a traditional gravitational body in that the  
119.        closer the device is to the center, the less force the well exerts;  
120.        the device behaves as if a spring were connected between itself and  
121.        the well's center. */ 
122.     if (hduVecMagnitude(positionTwell) < kGravityWellInfluence)  
123.     {  
124.         /* >  F = k * x  < 
125.            F: Force in Newtons (N)  
126.            k: Stiffness of the well (N/mm)  
127.            x: Vector from the device endpoint position to the center   
128.            of the well. */ 
129.         hduVecScale(force, positionTwell, kStiffness);  
130.     }  
131.  
132.     /* Send the force to the device. */ 
133.     hdSetDoublev(HD_CURRENT_FORCE, force);  
134.       
135.     /* End haptics frame. */ 
136.     hdEndFrame(hHD);  
137.  
138.     /* Check for errors and abort the callback if a scheduler error
139.        is detected. */ 
140.     if (HD_DEVICE_ERROR(error = hdGetError()))  
141.     {  
142.         hduPrintError(stderr, &error,   
143.                       "Error detected while rendering gravity well\n");  
144.           
145.         if (hduIsSchedulerError(&error))  
146.         {  
147.             return HD_CALLBACK_DONE;  
148.         }  
149.     }  
150.  
151.     /* Signify that the callback should continue running, i.e. that
152.        it will be called again the next scheduler tick. */ 
153.     return HD_CALLBACK_CONTINUE;  
154. } 

该程序在循环执行的任务中实时获取操作手柄的位置信息，并以此来计算输出力来模拟弹簧力。这里有几个需要注意的地方：

1. Haptic Frames：

为了保证数据访问的一致性，OpenHaptics提供了一种Frame框架结构，反馈给用户力的过程一般都是在力反馈帧中处理的，使用hdBeginFrame和hdEndFrame作为访问的开始和结束。在同一帧中多次调用hdGet类函数获取信息会得到相同的结果；多次调用hdSet类函数设置同一状态，则最后的调用会替代掉以前的（Forces are not actually sent to the device until the end of the frame. Setting the same state twice will replace the frst with the second）。即在帧的结尾，所有的属性改变才会得以应用。

Haptic frames defne a scope within which the device state is guaranteed to be consistent. Frames are bracketed by hdBeginFrame() and hdEndFrame() statements. At the start of the frame, the device state is updated and stored for use in that frame so that all state queries in the frame reflects a snapshot of that data. At the end of the frame, new state such as forces is written out to the device . Most haptics operations should be run within a frame. Calling operations within a frame ensures consistency for the data being used because state remains the same within the frame. Getting state outside a frame typically returns the state from the last frame. Setting state outside a frame typically results in an error.

HDAPI力反馈程序框架如下图所示：

2. 同步调用与异步调用：

所谓同步就是在发出一个“调用”时，在没有得到结果之前，该“调用”就不返回；而异步则是相反，“调用”在发出之后这个调用就直接返回了，即当一个异步过程调用发出后，调用者不会立刻得到结果。Synchronous calls only return after they are completed, so the application thread waits for a synchronous call before continuing. Asynchronous calls return immediately after being scheduled. 

同步调用主要用于获取设备当前状态，比如位置、力、开关状态等。Synchronous calls are primarily used for getting a snapshot of the state of the scheduler for the application. For example, if the application needs to query position or button state, or any other variable or state that the scheduler is changing, it should do so using a synchronous call.

下面是同步调用的一个例子：

1. // client data declaration  
2. struct DeviceDisplayState  
3. {  
4.     HDdouble position[3];  
5.     HDdouble force[3];  
6. }   
7.  
8. // usage of the above client data, within a simple callback.  
9. HDCallbackCode HDCALLBACK DeviceStateCallback(void *pUserData)   
10. {  
11.     DeviceDisplayState *pDisplayState = (DeviceDisplayState *)pUserData;  
12.       
13.     hdGetDoublev(HD_CURRENT_POSITION, pDisplayState->position);  
14.     hdGetDoublev(HD_CURRENT_FORCE,    pDisplayState->force);  
15.       
16.     return HD_CALLBACK_DONE;  // execute this only once  
17. }   
18.  
19.  
20. // get the current position of end-effector  
21. DeviceDisplayState state;  
22.  
23. hdScheduleSynchronous(DeviceStateCallback, &state, HD_MIN_SCHEDULER_PRIORITY); 

异步调用主要用于循环处理任务中，例如根据力反馈设备操作末端的位置来计算并输出力。Asynchronous calls are often the best mechanism for managing the haptics loop. For example, an asynchronous callback can persist in the scheduler to represent a haptics effect: during each iteration, the callback applies the effect to the device. 

1. HDCallbackCode HDCALLBACK CoulombCallback(void *data)  
2. {  
3.     HHD hHD = hdGetCurrentDevice();  
4.       
5.     hdBeginFrame(hHD);  
6.       
7.     HDdouble pos[3];  
8.     hdGetDoublev(HD_CURRENT_POSITION, pos); //retrieve the position of the end-effector.  
9.       
10.     HDdouble force[3];  
11.     forceField(pos, force);                 // given the position, calculate a force  
12.     hdSetDoublev(HD_CURRENT_FORCE, force);  // set the force to the device  
13.       
14.     hdEndFrame(hHD);                        // flush the force  
15.       
16.     return HD_CALLBACK_CONTINUE;            // run at every servo loop tick.  
17. }  
18.  
19. hdScheduleAsynchronous(AForceSettingCallback, 0, HD_DEFAULT_SCHEDULER_PRIORITY); 

3. 任务返回值：

•HD_CALLBACK_DONE （只执行一次）
•HD_CALLBACK_CONTINUE（循环执行）

根据不同的返回值，回调函数会在当前帧运行完毕后判断是否在下一帧再次运 行，当返回值为HD_CALLBACK_CONTINUE时，此回调函数在下一帧时会继续重新 运行；而当返回值为HD_CALLBACK_DONE 时，此回调函数在下一帧时不再次运行。Callbacks can be set to run either once or multiple times, depending on the callback’s return value. If the return value requests for the callback to continue, it is rescheduled and run again during the next scheduler tick. Otherwise it is taken off the scheduler and considered complete, and control is returned to the calling thread in the case of synchronous operations.

4. 任务优先级：

Callbacks are scheduled with a priority, which determines what order they are run in the scheduler. For every scheduler tick, each callback is always executed. The order the callbacks are executed depends on the priority; highest priority items are run before lowest. Operations with equal priority are executed in arbitrary order. 

下面再看一个获取设备信息的典型例子（examples\HD\console\QueryDevice）：

1. #include <stdio.h>  
2. #include <string.h>  
3. #include <conio.h>  
4.  
5. #include <HD/hd.h>  
6. #include <HDU/hduError.h>  
7. #include <HDU/hduVector.h>  
8.  
9. /* Holds data retrieved from HDAPI. */ 
10. typedef struct 
11. {  
12.     HDboolean m_buttonState;       /* Has the device button has been pressed. */ 
13.     hduVector3Dd m_devicePosition; /* Current device coordinates. */ 
14.     HDErrorInfo m_error;  
15. } DeviceData;  
16.  
17. static DeviceData gServoDeviceData;  
18.  
19. /*******************************************************************************
20. Checks the state of the gimbal button and gets the position of the device.  
21. *******************************************************************************/ 
22. HDCallbackCode HDCALLBACK updateDeviceCallback(void *pUserData)  
23. {  
24.     int nButtons = 0;  
25.  
26.     hdBeginFrame(hdGetCurrentDevice());  
27.  
28.     /* Retrieve the current button(s). */ 
29.     hdGetIntegerv(HD_CURRENT_BUTTONS, &nButtons);  
30.  
31.     /* In order to get the specific button 1 state, we use a bitmask to
32.     test for the HD_DEVICE_BUTTON_1 bit. */ 
33.     gServoDeviceData.m_buttonState =  
34.         (nButtons & HD_DEVICE_BUTTON_1) ? HD_TRUE : HD_FALSE;  
35.  
36.     /* Get the current location of the device (HD_GET_CURRENT_POSITION)
37.     We declare a vector of three doubles since hdGetDoublev returns  
38.     the information in a vector of size 3. */ 
39.     hdGetDoublev(HD_CURRENT_POSITION, gServoDeviceData.m_devicePosition);  
40.  
41.     /* Also check the error state of HDAPI. */ 
42.     gServoDeviceData.m_error = hdGetError();  
43.  
44.     /* Copy the position into our device_data tructure. */ 
45.     hdEndFrame(hdGetCurrentDevice());  
46.  
47.     return HD_CALLBACK_CONTINUE;  
48. }  
49.  
50.  
51. /*******************************************************************************
52. Checks the state of the gimbal button and gets the position of the device.  
53. *******************************************************************************/ 
54. HDCallbackCode HDCALLBACK copyDeviceDataCallback(void *pUserData)  
55. {  
56.     DeviceData *pDeviceData = (DeviceData *)pUserData;  
57.  
58.     // void *memcpy(void *dest, const void *src, size_t n);  
59.     memcpy(pDeviceData, &gServoDeviceData, sizeof(DeviceData));    
60.  
61.     return HD_CALLBACK_DONE;  
62. }  
63.  
64.  
65. /*******************************************************************************
66. Prints out a help string about using this example.  
67. *******************************************************************************/ 
68. void printHelp(void)  
69. {  
70.     static const char help[] = { "\  
71.                                  Press and release the stylus button to print out the current device location.\n\  
72.                                  Press and hold the stylus button to exit the application\n" };  
73.  
74.     fprintf(stdout, "%s\n", help);  
75. }  
76.  
77.  
78. /*******************************************************************************
79. This routine allows the device to provide information about the current  
80. location of the stylus, and contains a mechanism for terminating the  
81. application.  
82. Pressing the button causes the application to display the current location  
83. of the device.  
84. Holding the button down for N iterations causes the application to exit.  
85. *******************************************************************************/ 
86. void mainLoop(void)  
87. {  
88.     static const int kTerminateCount = 1000;  
89.     int buttonHoldCount = 0;  
90.  
91.     /* Instantiate the structure used to capture data from the device. */ 
92.     DeviceData currentData;  
93.     DeviceData prevData;  
94.  
95.     /* Perform a synchronous call to copy the most current device state. */ 
96.     hdScheduleSynchronous(copyDeviceDataCallback,  
97.         &currentData, HD_MIN_SCHEDULER_PRIORITY);  
98.  
99.     memcpy(&prevData, &currentData, sizeof(DeviceData));  
100.  
101.     printHelp();  
102.  
103.     /* Run the main loop until the gimbal button is held. */ 
104.     while (1)  
105.     {  
106.         /* Perform a synchronous call to copy the most current device state.
107.         This synchronous scheduler call ensures that the device state  
108.         is obtained in a thread-safe manner. */ 
109.         hdScheduleSynchronous(copyDeviceDataCallback,  
110.             &currentData,  
111.             HD_MIN_SCHEDULER_PRIORITY);  
112.  
113.         /* If the user depresses the gimbal button, display the current
114.         location information. */ 
115.         if (currentData.m_buttonState && !prevData.m_buttonState)  
116.         {  
117.             fprintf(stdout, "Current position: (%g, %g, %g)\n",  
118.                 currentData.m_devicePosition[0],  
119.                 currentData.m_devicePosition[1],  
120.                 currentData.m_devicePosition[2]);  
121.         }  
122.         else if (currentData.m_buttonState && prevData.m_buttonState)  
123.         {  
124.             /* Keep track of how long the user has been pressing the button.
125.             If this exceeds N ticks, then terminate the application. */ 
126.             buttonHoldCount++;  
127.  
128.             if (buttonHoldCount > kTerminateCount)  
129.             {  
130.                 /* Quit, since the user held the button longer than
131.                 the terminate count. */ 
132.                 break;  
133.             }  
134.         }  
135.         else if (!currentData.m_buttonState && prevData.m_buttonState)  
136.         {  
137.             /* Reset the button hold count, since the user stopped holding
138.             down the stylus button. */ 
139.             buttonHoldCount = 0;  
140.         }  
141.  
142.  
143.         /* Check if an error occurred. */ 
144.         if (HD_DEVICE_ERROR(currentData.m_error))  
145.         {  
146.             hduPrintError(stderr, &currentData.m_error, "Device error detected");  
147.  
148.             if (hduIsSchedulerError(&currentData.m_error))  
149.             {  
150.                 /* Quit, since communication with the device was disrupted. */ 
151.                 fprintf(stderr, "\nPress any key to quit.\n");  
152.                 break;  
153.             }  
154.         }  
155.  
156.         /* Store off the current data for the next loop. */ 
157.         memcpy(&prevData, &currentData, sizeof(DeviceData));  
158.     }  
159. }  
160.  
161. /*******************************************************************************
162. Main function.  
163. Sets up the device, runs main application loop, cleans up when finished.  
164. *******************************************************************************/ 
165. int main(int argc, char* argv[])  
166. {  
167.     HDSchedulerHandle hUpdateHandle = 0;  
168.     HDErrorInfo error;  
169.  
170.     /* Initialize the device, must be done before attempting to call any hd
171.     functions. */ 
172.     HHD hHD = hdInitDevice(HD_DEFAULT_DEVICE);  
173.     if (HD_DEVICE_ERROR(error = hdGetError()))  
174.     {  
175.         hduPrintError(stderr, &error, "Failed to initialize the device");  
176.         fprintf(stderr, "\nPress any key to quit.\n");  
177.         return -1;  
178.     }  
179.  
180.     /* Schedule the main scheduler callback that updates the device state. */ 
181.     hUpdateHandle = hdScheduleAsynchronous(  
182.         updateDeviceCallback, 0, HD_MAX_SCHEDULER_PRIORITY);  
183.  
184.     /* Start the servo loop scheduler. */ 
185.     hdStartScheduler();  
186.     if (HD_DEVICE_ERROR(error = hdGetError()))  
187.     {  
188.         hduPrintError(stderr, &error, "Failed to start the scheduler");  
189.         fprintf(stderr, "\nPress any key to quit.\n");  
190.         return -1;  
191.     }  
192.  
193.     /* Run the application loop. */ 
194.     mainLoop();  
195.  
196.     /* For cleanup, unschedule callbacks and stop the servo loop. */ 
197.     hdStopScheduler();  
198.     hdUnschedule(hUpdateHandle);  
199.     hdDisableDevice(hHD);  
200.  
201.     return 0;  
202. } 

主函数中开启updateDeviceCallback异步任务后，该任务不停地刷新设备末端的位置以及按钮状态等信息，保存在静态全局变量gServoDeviceData中。在主程序的mainLoop循环中使用copyDeviceDataCallback同步调用方式获取设备状态信息，然后进行判断。按一下操作手柄上的按钮打印一条当前位置信息；长按按钮超过一定时间则退出mainLoop循环，结束程序。

值得注意的是主线程中函数获取Servo Loop线程（任务线程）中的数据，可以通过同步调用来实现，是一种线程安全（thread-safe）方式。线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。hdScheduleSynchronous：Typically used as a synchronization mechanism between the servo loop thread and other threads in the application. For example, if the main application thread needs to access the position or button state, it can do so through a synchronous scheduler call. Can be used for synchronously copying state from the servo loop.

在mainLoop函数中也可以直接访问全局变量gServoDeviceData来获取设备信息，但这种方式是线程不安全的，即不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。如果其他线程企图访问一个处于不可用状态的对象，该对象将不能正确响应从而产生无法预料的结果，如何避免这种情况发生是线程安全性的核心问题。