Tipro API
Communicate with Tipro devices
TiproHidApi.h
1 //20190709added from tiprohidapiwindows
2 
3 #ifndef TIPROHIDAPI_H__
4 #define TIPROHIDAPI_H__
5 
6 
7 
8 #include <wchar.h>
9 
10 #include "TiproHidDevice.h"
11 
12 
13 #ifdef _WIN32
14  #define TIPROHIDAPI_API_EXPORT __declspec(dllexport)
15  #define TIPROHIDAPI_API_CALL
16 #else
17  #define TIPROHIDAPI_API_EXPORT
18  #define TIPROHIDAPI_API_CALL
19 #endif
20 
21 #define TIPROHIDAPI_API_EXPORT_CALL TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL
24 /****************************************************************************/
25 /* Tiprobus / module functions and definitions */
26 /****************************************************************************/
27 //
28 // Module type definitions:
29 #define MODULE_TYPE_UNKNOWN 0x00;
30 #define MODULE_TYPE_MATRIX 0x01;
31 #define MODULE_TYPE_SPEAKERBOX 0x02;
32 #define MODULE_TYPE_SPEAKERBOX_VOLUME 0x03;
33 #define MODULE_TYPE_CHAMELEON 0x04;
34 #define MODULE_TYPE_HANDSET 0x05;
35 #define MODULE_TYPE_BF15 0x06;
36 #define MODULE_TYPE_BF10 0x07;
37 #define MODULE_TYPE_BF10_AUDIO 0x08;
38 #define MODULE_TYPE_BF20 0x09;
39 #define MODULE_TYPE_BF20_AUDIO 0x0A;
40 #define MODULE_TYPE_BF22 0x0B;
41 #define MODULE_TYPE_BF22_LINEKEYS 0x0C;
42 #define MODULE_TYPE_SPEAKERBOX_104 0x0D;
43 #define MODULE_TYPE_BF07 0x0E;
44 #define MODULE_TYPE_BF07_DIALPAD 0x0F;
45 #define MODULE_TYPE_UNSUPPORTED 0xFF;
46 
47 
48 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDTouchscreenDisable(TiproHidDevice *device);
49 /* Disables touchscreen */
50 /* return value : command status : 0 == OK, else error code */
51 
52 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDTouchscreenEnable(TiproHidDevice *device);
53 /* Enables touchscreen */
54 /* return value : command status : 0 == OK, else error code */
55 
56 
57 #if 0 //20200430
58 
59 
60 #ifdef __cplusplus
61 extern "C" {
62 #endif
63 
64 
65 /*##PBP DEPLOY*/
66 // The following ifdef block is the standard way of creating macros which make exporting
67 // from a DLL simpler. All files within this DLL are compiled with the TIPROHIDAPI_EXPORTS
68 // symbol defined on the command line. this symbol should not be defined on any project
69 // that uses this DLL. This way any other project whose source files include this file see
70 // TIPROHIDAPI_API functions as being imported from a DLL, wheras this DLL sees symbols
71 // defined with this macro as being exported.
72 //20190709 #ifdef TIPROHIDAPI_EXPORTS
73 //20190709 #define TIPROHIDAPI_API __declspec(dllexport)
74 //20190709 #else
75 //20190709 #define TIPROHIDAPI_API __declspec(dllimport)
76 //20190709 #endif
77 
78 //20190812copied from hidapi.h
79  struct tipro_hid_device_;
80  typedef struct tipro_hid_device_ tipro_hid_device;
84 //20200124
85 // 0-no log, 1-exported functons in/out
86 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetLogLevel(int level);
87 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetLogLevel(int *level);
88 
89 
90 
91 /****************************************************************************/
92 /* HIDAPI functions (FW Level 1 required) */
93 /****************************************************************************/
94 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetLuminance(TiproHidDevice *device, int nLum);
95 /* Sets the luminance of the LCD screen */
96 /* arguments (IN) : Relative luminance (0-20) */
97 /* return value : command status : 0 == OK, else error code */
98 
99 
100 
101 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetLeds(TiproHidDevice *device, int nLEDs);
102 /* Sets the user-defined LED state */
103 /* arguments (IN) : LEDs to turn ON/OFF (0x00-0x0F) */
104 /* return value : command status : 0 == OK, else error code */
105 
106 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDDetectDevices(void);
107 //int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDDetectDevices(void);
108 /* Detect Tipro HID API supported devices */
109 /* return value : command status : 0 == OK, else error code */
110 
111 /****************************************************************************/
112 /* HIDAPI functions (FW Level 2 required) */
113 /****************************************************************************/
114 
115 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDEnumerateModules(TiproHidDevice *device);
116 //int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDEnumerateModules(void);
117 /* Enumerates devices on TiproBus */
118 /* return value : command status : 0 == OK, else error code */
119 
120 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDReset(TiproHidDevice *device);
121 /* Sends Reset to the controller */
122 /* return value : command status : 0 == OK, else error code */
123 
124 /****************************************************************************/
125 /* SPEAKERBOX FUNCTIONS */
126 /****************************************************************************/
127 
128 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetSpeakerLevel(TiproHidDevice *device, int nFsNum, int nLevel);
129 /* Sets the level of the speakers */
130 /* arguments (IN) : selected speakerbox module number */
131 /* : speaker level */
132 /* return value : command status : 0 == OK, else error code */
133 
134 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetSpeakerLevel(TiproHidDevice *device, int nFsNum, int *nLevel);
135 /* Returns the level of the speakers */
136 /* arguments (IN) : selected speakerbox module number */
137 /* : speaker level */
138 /* return value : command status : 0 == OK, else error code */
139 
140 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetHandsetState(TiproHidDevice *device, int nHandsetNum, int *nPTTKey, int *nHookState);
141 /* Returns the state of the keys */
142 /* arguments (IN) : selected handset module number */
143 /* arguments (OUT) : PTT key state (KEY_PRESSED / KEY_RELEASED) */
144 /* : Hook state (KEY_PRESSED / KEY_RELEASED) */
145 /* return value : command status : 0 == OK, else error code */
146 
147 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetHandsetStateEx (TiproHidDevice *device, int nHandsetNum, int *nPTTKey, int *nHookState);
148 /* Returns the state of the keys */
149 /* arguments (IN) : selected handset module number */
150 /* arguments (OUT) : PTT key state (KEY_PRESSED / KEY_RELEASED) */
151 /* : Hook state (KEY_PRESSED / KEY_RELEASED) */
152 /* : if any of OUT arguments is NULL, handset state is */
153 /* : sent to system, otherwise just RAW is returned */
154 /* return value : command status : 0 == OK, else error code */
155 
156 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetSbxKeyState (TiproHidDevice *device, int nFsNum, int nKey, int *nState);
157 /* Returns the state of the keys */
158 /* arguments (IN) : selected speakerbox module number */
159 /* : key index */
160 /* arguments (OUT) : state of the key (KEY_PRESSED / KEY_RELEASED) */
161 /* return value : command status : 0 == OK, else error code */
162 
163 extern int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetSbxLEDState (TiproHidDevice *device, int nFsNum, int nKey, int nState);
164 /* Sets the LED state of the illuminated keys */
165 /* arguments (IN) : selected speakerbox module number */
166 /* : illuminated key index */
167 /* : state of the LED (LED_ON/LED_OFF) */
168 /* return value : command status : 0 == OK, else error code */
169 
170 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetSbxLEDState (TiproHidDevice *device, int nFsNum, int nKey, int *nState);
171 /* Returns the LED state of the illuminated keys */
172 /* arguments (IN) : selected speakerbox module number */
173 /* : illuminated key index */
174 /* arguments (OUT) : state of the LED (LED_ON/LED_OFF) */
175 /* return value : command status : 0 == OK, else error code */
176 
177 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetExternalDeviceLevel (TiproHidDevice *device, int nFsNum, int nLevel);
178 /* Sets the level of the connected headset/handset device */
179 /* arguments (IN) : selected speakerbox module number */
180 /* : level of the signal */
181 /* return value : command status : 0 == OK, else error code */
182 
183 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetExternalDeviceLevel (TiproHidDevice *device, int nFsNum, int *nLevel);
184 /* Returns the current level of the connected headset/handset device */
185 /* arguments (IN) : selected speakerbox module number */
186 /* arguments (OUT) : level of the signal */
187 /* return value : command status : 0 == OK, else error code */
188 
189 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetExternalHeadsetState (TiproHidDevice *device, int nFsNum, int *nState);
190 /* Returns the state of the headset */
191 /* arguments (IN) : selected speakerbox module number */
192 /* arguments (OUT) : headset state */
193 /* (HEADSET_CONNECTED / HEADSET_DISCONNECTED) */
194 /* */
195 /* return value : command status : 0 == OK, else error code */
196 
197 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDMuteMicrophone (TiproHidDevice *device, int nFsNum, int nMute);
198 /* Mutes/un-mutes the microphone signal */
199 /* arguments (IN) : selected speakerbox module number */
200 /* : mute/un-mute microphone */
201 /* return value : command status : 0 == OK, else error code */
202 
203 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSpeakerboxGoOnline (TiproHidDevice *device, int nFsNum);
204 /* Puts speakerbox to On-line mode */
205 /* arguments (IN) : selected speakerbox module number */
206 /* return value : command status : 0 == OK, else error code */
207 /* */
208 
209 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDIsSpeakerboxOnline (TiproHidDevice *device, int nFsNum, int *nOnline);
210 /* Returns On-line / Off-line mode */
211 /* arguments (IN) : selected speakerbox module number */
212 /* arguments (OUT) : 0 - Offline ; 1 - Online */
213 /* return value : command status : 0 == OK, else error code */
214 /* */
215 
216 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetAlertLine (TiproHidDevice *device, int nFsNum, int nMode);
217 /* Sets the function (mode) of the alert line */
218 /* arguments (IN) : selected speakerbox module number */
219 /* : mode (ALERT, VOICE, NOT USED) */
220 /* return value : command status : 0 == OK, else error code */
221 /* */
222 /* */
223 /* */
224 /* ON-Line ONLY! */
225 
226 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetAlertLine (TiproHidDevice *device, int nFsNum, int *nMode);
227 /* returns the function (mode) of the alert line */
228 /* arguments (IN) : selected speakerbox module number */
229 /* arguments (OUT) : mode (ALERT, VOICE, NOT USED) */
230 /* return value : command status : 0 == OK, else error code */
231 /* */
232 /* */
233 /* */
234 /* ON-Line ONLY! */
235 
236 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetActiveDevice (TiproHidDevice *device, int nFsNum, int nDevice);
237 /* Sets the device where both speaker and microphone signals */
238 /* will be switched to */
239 /* arguments (IN) : selected speakerbox module number */
240 /* : device to be made active */
241 /* return value : command status : 0 == OK, else error code */
242 /* */
243 /* */
244 /* */
245 /* ON-Line ONLY! */
246 
247 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetMicrophoneLevel (TiproHidDevice *device, int nFsNum, int *nLevel);
248 /* Returns the level of the microphone signal */
249 /* arguments (IN) : selected speakerbox module number */
250 /* arguments (OUT): microphone level */
251 /* return value : command status : 0 == OK, else error code */
252 
253 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneLevel (TiproHidDevice *device, int nFsNum, int nLevel);
254 /* Sets the level of the microphone signal */
255 /* arguments (IN) : selected speakerbox module number */
256 /* : microphone level */
257 /* return value : command status : 0 == OK, else error code */
258 
259 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneLevelEx (TiproHidDevice *device, int nFsNum, int nLevel, int nDevice);
260 /* Sets the level of the microphone signal */
261 /* arguments (IN) : selected speakerbox module number */
262 /* : microphone level */
263 /* : device to set (handsfree, handset/headset) */
264 /* return value : command status : 0 == OK, else error code */
265 
266 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetMicrophoneOptimalDistance (TiproHidDevice *device, int nFsNum, int *nDistance);
267 /* Returns the optimal distance of the handsfree microphone */
268 /* arguments (IN) : selected speakerbox module number */
269 /* arguments (OUT): microphone optimal distance */
270 /* return value : command status : 0 == OK, else error code */
271 
272 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneOptimalDistance (TiproHidDevice *device, int nFsNum, int nDistance);
273 /* Sets the optimal distance for the handsfree microphone */
274 /* arguments (IN) : selected speakerbox module number */
275 /* : microphone optimal distance */
276 /* return value : command status : 0 == OK, else error code */
277 
278 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneThreshold (TiproHidDevice *device, int nFsNum, int nThreshold);
279 /* Sets the microphone threshold */
280 /* arguments (IN) : selected speakerbox module number */
281 /* : microphone threshold */
282 /* return value : command status : 0 == OK, else error code */
283 
284 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetMicrophoneThreshold (TiproHidDevice *device, int nFsNum, int *nThreshold);
285 /* Returns the microphone threshold */
286 /* arguments (IN) : selected speakerbox module number */
287 /* arguments (OUT): microphone threshold */
288 /* return value : command status : 0 == OK, else error code */
289 
290 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneCompression (TiproHidDevice *device, int nFsNum, int nCompression);
291 /* Sets the microphone compression */
292 /* arguments (IN) : selected speakerbox module number */
293 /* : microphone compression */
294 /* return value : command status : 0 == OK, else error code */
295 
296 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetMicrophoneCompression (TiproHidDevice *device, int nFsNum, int *nCompression);
297 /* Returns the microphone compression */
298 /* arguments (IN) : selected speakerbox module number */
299 /* arguments (OUT): microphone compression */
300 /* return value : command status : 0 == OK, else error code */
301 
303 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneThresholdEx (TiproHidDevice *device, int nFsNum, int nThreshold, int nDevice);
304 /* Sets the specific device's microphone threshold */
305 /* arguments (IN) : selected speakerbox module number */
306 /* : microphone threshold */
307 /* : device to set (handsfree, handset/headset) */
308 /* return value : command status : 0 == OK, else error code */
309 
310 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetMicrophoneCompressionEx (TiproHidDevice *device, int nFsNum, int nCompression, int nDevice);
311 /* Sets the specific device's microphone compression */
312 /* arguments (IN) : selected speakerbox module number */
313 /* : microphone compression */
314 /* : device to set (handsfree, handset/headset) */
315 /* return value : command status : 0 == OK, else error code */
316 
317 /* Supported if firmware with blink functionality */
318 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSetSbxLEDBlinkSpeed (TiproHidDevice *device, int nFsNum, int nTBlinkA, int nTBlinkB);
319 /* Sets the LED blink timings */
320 /* arguments (IN) : selected speakerbox module number */
321 /* : ON time in ms (1..5000) */
322 /* : OFF time in ms (1..5000) */
323 /* return value : command status : 0 == OK, else error code */
324 
325 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetSbxLEDBlinkSpeed (TiproHidDevice *device, int nFsNum, int *nTBlinkA, int *nTBlinkB);
326 /* Get LED blink timings */
327 /* arguments (IN) : selected speakerbox module number */
328 /* arguments (OUT): ON time in ms (1..5000) */
329 /* : OFF time in ms (1..5000) */
330 /* return value : command status : 0 == OK, else error code */
331 
332 /****************************************************************************/
333 /* CHAMELEON FUNCTIONS */
334 /****************************************************************************/
335 
336 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmGoOnline (TiproHidDevice *device, int nChmNum);
337 /* Puts Chameleon into On-Line operating mode. */
338 /* arguments (IN) : selected Chameleon module number */
339 /* arguments (OUT) : none */
340 /* return value : command status : 0 == OK, else error code */
341 
342 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmDisplayIcon (TiproHidDevice *device, int nChmNum, struct CHM_ICON_DATA IconData);
343 /* Displays the icon from the library on the specified key. */
344 /* arguments (IN) : selected Chameleon module number */
345 /* : address of the key (0x00-0x0F) */
346 /* : video type of the icon (NORMAL or INVERSE) */
347 /* : index of the icon in the icon library */
348 /* arguments (OUT) : none */
349 /* return value : command status : 0 == OK, else error code */
350 
351 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmDisplayBitmap (TiproHidDevice *device, int nChmNum, int nKeyAddr, int nVideoType, struct CHM_BITMAP_DATA BitmapData);
352 /* Displays the bitmap on the specified key. */
353 /* arguments (IN) : selected Chameleon module number */
354 /* : address of the key (0x00-0x0F) */
355 /* : video type of the icon (NORMAL or INVERSE) */
356 /* : bitmap data */
357 /* arguments (OUT) : none */
358 /* return value : command status : 0 == OK, else error code */
359 
360 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmChangeBacklighting (TiproHidDevice *device, int nChmNum, struct CHM_BACKLIGHTING_DATA BacklightingData);
361 /* Sets the backlighting parameters for the addressed LCD key. */
362 /* arguments (IN) : selected Chameleon module number */
363 /* : address of the key (0x00-0x0F) */
364 /* : first color for the key backlight */
365 /* : alternate color for the key backlight */
366 /* : alternating frequency (switching from color1 to color2)*/
367 /* arguments (OUT) : none */
368 /* return value : command status : 0 == OK, else error code */
369 
370 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmGoToPage (TiproHidDevice *device, int nChmNum, int nPageNumber);
371 /* Loads the selected page settings from the configuration memory. */
372 /* arguments (IN) : selected Chameleon module number */
373 /* : page number */
374 /* arguments (OUT) : none */
375 /* return value : command status : 0 == OK, else error code */
376 
377 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmGetPageNumber (TiproHidDevice *device, int nChmNum, int *nPageNumber);
378 /* Returns current page number. */
379 /* arguments (IN) : selected Chameleon module number */
380 /* arguments (OUT) : current page number */
381 /* return value : command status : 0 == OK, else error code */
382 
383 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDChmGetNumberOfPages (TiproHidDevice *device, int nChmNum, int *nPages);
384 /* Returns number of preprogrammed pages. */
385 /* arguments (IN) : selected Chameleon module number */
386 /* arguments (OUT) : number of preprogrammed pages */
387 /* return value : command status : 0 == OK, else error code */
388 
389 /****************************************************************************/
390 /* BF10 FUNCTIONS */
391 /****************************************************************************/
392 /* */
393 /* Old functions for BeFree and Speakerbox are updated to support new */
394 /* functionality. Some functions are calling old functions with correct */
395 /* paramters. */
396 /* */
397 /****************************************************************************/
398 
399 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetLuminance (TiproHidDevice *device, int nIndex);
400 /* Sets luminance for both stripe and LCD backlight */
401 /* arguments (IN) : lumninance index (0-darkest; 10-brightest) */
402 /* arguments (OUT) : none */
403 /* return value : command status : 0 == OK, else error code */
404 
405 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10TouchscreenDisable(TiproHidDevice *device);
406 /* Disables touchscreen */
407 /* return value : command status : 0 == OK, else error code */
408 
409 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10TouchscreenEnable(TiproHidDevice *device);
410 /* Enables touchscreen */
411 /* return value : command status : 0 == OK, else error code */
412 
413 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetSpeakerLevel(TiproHidDevice *device, int nLevel);
414 /* Sets the level of the speakers */
415 /* arguments (IN) : speaker level */
416 /* return value : command status : 0 == OK, else error code */
417 
418 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetSpeakerLevel(TiproHidDevice *device, int *nLevel);
419 /* Returns the level of the speakers */
420 /* arguments (OUT) : speaker level */
421 /* return value : command status : 0 == OK, else error code */
422 
423 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetPTTKeyState (TiproHidDevice *device, int *nState);
424 /* Returns the state of the PTT key */
425 /* arguments (OUT) : state of the key (KEY_PRESSED / KEY_RELEASED) */
426 /* return value : command status : 0 == OK, else error code */
427 
428 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetPTTKeyLEDState (TiproHidDevice *device, int nState);
429 /* Sets the LED state of illuminated PTT key */
430 /* arguments (IN) : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
431 /* return value : command status : 0 == OK, else error code */
432 
433 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetPTTKeyLEDStateEx (TiproHidDevice *device, int nState, int nTBlinkOn, int nTBlinkOff);
434 /* Sets the operation of the illuminated PTT key with more paramters */
435 /* arguments (IN) : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
436 /* : On period for blink mode (ms) */
437 /* : Off period for blink mode (ms) */
438 /* return value : command status : 0 == OK, else error code */
439 
440 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetPTTKeyLEDState (TiproHidDevice *device, int *nState);
441 /* Returns the LED state of the illuminated PTT Key */
442 /* arguments (OUT) : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
443 /* return value : command status : 0 == OK, else error code */
444 
445 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10MuteMicrophone (TiproHidDevice *device, int nMute);
446 /* Mutes/un-mutes the microphone signal */
447 /* arguments (IN) : mute/un-mute microphone */
448 /* return value : command status : 0 == OK, else error code */
449 
450 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetAutoLuminance (TiproHidDevice *device, int nAutoMode);
451 /* Sets luminance for both stripe and LCD backlight to be controlled by */
452 /* ambient light sensor. */
453 /* arguments (IN) : Auto luminance mode */
454 /* return value : command status : 0 == OK, else error code */
455 
456 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetAutoLuminance (TiproHidDevice *device, int *nAutoMode);
457 /* Returns the mode of the auto controlled luminance */
458 /* arguments (OUT) : Auto luminance mode */
459 /* return value : command status : 0 == OK, else error code */
460 
461 // functions that are also missing in the speakerbox part
462 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetMicrophoneLevel (TiproHidDevice *device, int nLevel);
463 /* Sets the level of the microphone signal */
464 /* arguments (IN) : microphne level */
465 /* return value : command status : 0 == OK, else error code */
466 
467 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetMicrophoneOptimalDistance (TiproHidDevice *device, int nDistance);
468 /* Sets the optimal distance of the handsfree microphone signal */
469 /* arguments (IN) : microphone optimal distance */
470 /* return value : command status : 0 == OK, else error code */
471 
472 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetMicrophoneThreshold (TiproHidDevice *device, int nThreshold);
473 /* Sets threshold for the microphone signal */
474 /* arguments (IN) : microphone threshold */
475 /* return value : command status : 0 == OK, else error code */
476 
477 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetMicrophoneCompression (TiproHidDevice *device, int nCompression);
478 /* Sets compression for the microphone signal */
479 /* arguments (IN) : microphone compression */
480 /* return value : command status : 0 == OK, else error code */
481 
482 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10SetAnalogAudio(TiproHidDevice *device, int nSettings);
483 /* Sets the Analog audio options */
484 /* arguments (IN) : select which analog channel is added to the output */
485 /* return value : command status : 0 == OK, else error code */
486 
487 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetAnalogAudio(TiproHidDevice *device, int *nSettings);
488 /* Returns Analog audio options */
489 /* arguments (OUT): returns which analog channel is added to the output */
490 /* return value : command status : 0 == OK, else error code */
491 
492 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetMicrophoneLevel (TiproHidDevice *device, int *nLevel);
493 /* Returns the level of the microphone signal */
494 /* arguments (OUT) : microphone level */
495 /* return value : command status : 0 == OK, else error code */
496 
497 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetMicrophoneOptimalDistance (TiproHidDevice *device, int *nRange);
498 /* Returns the optimal distance of the handsfree microphone signal */
499 /* arguments (OUT) : microphone optimal distance */
500 /* return value : command status : 0 == OK, else error code */
501 
502 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetMicrophoneThreshold (TiproHidDevice *device, int *nThreshold);
503 /* Returns threshold for the microphone signal */
504 /* arguments (OUT) : microphone threshold */
505 /* return value : command status : 0 == OK, else error code */
506 
507 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10GetMicrophoneCompression (TiproHidDevice *device, int *nCompression);
508 /* Returns compression for the microphone signal */
509 /* arguments (OUT) : microphone compression */
510 /* return value : command status : 0 == OK, else error code */
511 
512 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF10EnableManualMicrophoneControl(TiproHidDevice *device, int nEnable);
513 /* Enables manual control of microphone. */
514 /* If enabled microphone mute and LED are controlled exclusively by API. */
515 /* arguments (IN) : enable / disable manual control */
516 /* return value : command status : 0 == OK, else error code */
517 
518 /****************************************************************************/
519 /* BF20 FUNCTIONS */
520 /****************************************************************************/
521 
522 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetPCMScenario(TiproHidDevice *device, int nScenario);
523 /* Set PCM scenario */
524 /* arguments (IN) : PCM scenario (AB2LR / LR2LR) */
525 /* return value : command status : 0 == OK, else error code */
526 
527 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetPCMScenario(TiproHidDevice *device, int *nScenario, int *nInitScenario);
528 /* Get PCM scenario */
529 /* arguments (OUT) : PCM scenario (AB2LR / LR2LR) */
530 /* : Initial state from EEPROM */
531 /* return value : command status : 0 == OK, else error code */
532 
533 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMicAmpMode(TiproHidDevice *device, int nMicAmpMode);
534 /* Set Microphone amplifier mode (Linear/Logarithmic) */
535 /* arguments (IN) : Microphone amplifier mode (LIN/LOG) */
536 /* return value : command status : 0 == OK, else error code */
537 
538 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMicAmpMode(TiproHidDevice *device, int *nMicAmpMode, int *nInitMicAmpMode);
539 /* arguments (OUT) : Microphone amplifier mode (LIN/LOG) */
540 /* : Initial state from EEPROM */
541 /* return value : command status : 0 == OK, else error code */
542 
543 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetLFSpeakerState(TiproHidDevice *device, int nState);
544 /* Set LF speaker state (ON/OFF) */
545 /* arguments (IN) : LF speaker state (on/off) */
546 /* return value : command status : 0 == OK, else error code */
547 
548 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetLFSpeakerState(TiproHidDevice *device, int *nState, int *nInitState);
549 /* Get LF speaker state */
550 /* arguments (OUT) : LF speaker state (on/off) */
551 /* : Initial state from EEPROM */
552 /* return value : command status : 0 == OK, else error code */
553 
554 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMicOnVUState(TiproHidDevice *device, int nState);
555 /* Sets if microphone level is shown on the VU-meter (ON/OFF) */
556 /* arguments (IN) : microphone on VU-meter state (on/off) */
557 /* return value : command status : 0 == OK, else error code */
558 
559 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMicOnVUState(TiproHidDevice *device, int *nState, int *nInitState);
560 /* Get microphone level shown on VU-meter state */
561 /* arguments (OUT) : microphone level on VU-meter state (on/off) */
562 /* : Initial state from EEPROM */
563 /* return value : command status : 0 == OK, else error code */
564 
565 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMic2LineInState(TiproHidDevice *device, int nState);
566 /* Sets the connection state (ON/OFF) of the gooseneck microphone to the */
567 /* LINE-IN port on the motherboard */
568 /* arguments (IN) : connection state (ON/OFF) */
569 /* return value : command status : 0 == OK, else error code */
570 
571 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMic2LineInState(TiproHidDevice *device, int *nState, int *nInitState);
572 /* Returns the connection state (ON/OFF) of the gooseneck microphone to the */
573 /* LINE-IN port on the motherboard */
574 /* arguments (OUT) : connection state (ON/OFF) */
575 /* : initial state from EEPROM */
576 /* return value : command status : 0 == OK, else error code */
577 
578 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetLineOut2SpkMode(TiproHidDevice *device, int nMode);
579 /* Sets the connection mode (OFF/L/R/LR) of the motherboard LINE-OUT port */
580 /* to the speakers. */
581 /* arguments (IN) : connection mode (OFF/L/R/LR) */
582 /* return value : command status : 0 == OK, else error code */
583 
584 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetLineOut2SpkMode(TiproHidDevice *device, int *nMode, int *nInitMode);
585 /* Returns the connection mode (OFF/L/R/LR) of the motherboard LINE-OUT */
586 /* port to the speakers. */
587 /* arguments (OUT) : connection mode (OFF/L/R/LR) */
588 /* : initial state from EEPROM */
589 /* return value : command status : 0 == OK, else error code */
590 
591 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetEchoMode(TiproHidDevice *device, int nMode);
592 /* Sets the echo canceler mode (OFF/L/R/LR) */
593 /* arguments (IN) : echo canceler mode (OFF/L/R/LR) */
594 /* return value : command status : 0 == OK, else error code */
595 
596 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetEchoMode(TiproHidDevice *device, int *nMode, int *nInitMode);
597 /* Returns the echo canceler mode (OFF/L/R/LR) */
598 /* arguments (OUT) : echo canceler mode (OFF/L/R/LR) */
599 /* : initial state from EEPROM */
600 /* return value : command status : 0 == OK, else error code */
601 
602 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20TouchscreenDisable(TiproHidDevice *device);
603 /* Disables touchscreen */
604 /* return value : command status : 0 == OK, else error code */
605 
606 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20TouchscreenEnable(TiproHidDevice *device);
607 /* Enables touchscreen */
608 /* return value : command status : 0 == OK, else error code */
609 
610 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetPTTKeyLEDState(TiproHidDevice *device, int nState);
611 /* Sets the LED state of illuminated PTT key */
612 /* arguments (IN) : PTT LED state (PTT_LED_ON/PTT_LED_OFF/PTT_LED_BLINK) */
613 /* return value : command status : 0 == OK, else error code */
614 
615 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetPTTKeyLEDStateEx(TiproHidDevice *device, int nState, int nTBlinkOn, int nTBlinkOff);
616 /* Sets the operation of the illuminated PTT key with more paramters */
617 /* arguments (IN) : PTT LED state (PTT_LED_ON/PTT_LED_OFF/PTT_LED_BLINK) */
618 /* : On period for blink mode (ms) */
619 /* : Off period for blink mode (ms) */
620 /* return value : command status : 0 == OK, else error code */
621 
622 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetPTTKeyLEDState(TiproHidDevice *device, int *nState);
623 /* Returns the LED state of the illuminated PTT Key */
624 /* arguments (OUT) : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
625 /* return value : command status : 0 == OK, else error code */
626 
627 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20MuteMicrophone(TiproHidDevice *device, int nMute);
628 /* Mutes/un-mutes the microphone signal */
629 /* arguments (IN) : mute/un-mute microphone */
630 /* return value : command status : 0 == OK, else error code */
631 
632 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetLeftSpeakerLevel(TiproHidDevice *device, int nLevel);
633 /* Sets the level of the left speaker */
634 /* arguments (IN) : speaker level */
635 /* return value : command status : 0 == OK, else error code */
636 
637 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetLeftSpeakerLevel(TiproHidDevice *device, int *nLevel);
638 /* Returns the level of the left speaker */
639 /* arguments (OUT) : speaker level */
640 /* return value : command status : 0 == OK, else error code */
641 
642 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetRightSpeakerLevel(TiproHidDevice *device, int nLevel);
643 /* Sets the level of the right speaker */
644 /* arguments (IN) : speaker level */
645 /* return value : command status : 0 == OK, else error code */
646 
647 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetRightSpeakerLevel(TiproHidDevice *device, int *nLevel);
648 /* Returns the level of the right speaker */
649 /* arguments (OUT) : speaker level */
650 /* return value : command status : 0 == OK, else error code */
651 
652 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMicrophoneLevel(TiproHidDevice *device, int nLevel, bool bSetInit);
653 /* Sets the gooseneck microphone level */
654 /* arguments (IN) : microphone level */
655 /* : write initial state to EEPROM */
656 /* return value : command status : 0 == OK, else error code */
657 
658 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMicrophoneLevel(TiproHidDevice *device, int *nLevel, int *nInitLevel);
659 /* Returns the googeneck microphone level */
660 /* arguments (OUT) : microphone level */
661 /* : initial state from EEPROM */
662 /* return value : command status : 0 == OK, else error code */
663 
664 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMicrophoneOptimalDistance(TiproHidDevice *device, int nDistance, bool bSetInit);
665 /* Sets the microphone optimal distance */
666 /* arguments (IN) : microphone optimal distance */
667 /* : write initial state to EEPROM */
668 /* return value : command status : 0 == OK, else error code */
669 
670 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMicrophoneOptimalDistance(TiproHidDevice *device, int *nDistance, int *nInitDistance);
671 /* Gets the microphone optimal distance */
672 /* arguments (OUT) : microphone optimal distance */
673 /* : initial state from EEPROM */
674 /* return value : command status : 0 == OK, else error code */
675 
676 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMicrophoneThreshold(TiproHidDevice *device, int *nThreshold, int *nInitThreshold);
677 /* Returns threshold for the microphone signal */
678 /* arguments (OUT) : microphone threshold */
679 /* : initial state from EEPROM */
680 /* return value : command status : 0 == OK, else error code */
681 
682 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMicrophoneThreshold(TiproHidDevice *device, int nThreshold, bool bSetInit);
683 /* Sets threshold for the microphone signal */
684 /* arguments (IN) : microphone threshold */
685 /* : write initial state to EEPROM */
686 /* return value : command status : 0 == OK, else error code */
687 
688 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetMicrophoneCompression(TiproHidDevice *device, int *nCompression, int *nInitCompression);
689 /* Returns compression for the microphone signal */
690 /* arguments (OUT) : microphone compression */
691 /* : initial state from EEPROM */
692 /* return value : command status : 0 == OK, else error code */
693 
694 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetMicrophoneCompression(TiproHidDevice *device, int nCompression, bool bSetInit);
695 /* Sets compression for the microphone signal */
696 /* arguments (IN) : microphone compression */
697 /* : write initial state to EEPROM */
698 /* return value : command status : 0 == OK, else error code */
699 
700 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20SetLuminance(TiproHidDevice *device, int nLuminance);
701 /* Sets luminance for both stripe and LCD backlight */
702 /* arguments (IN) : luminance index (0-darkest; 20-brightest) */
703 /* return value : command status : 0 == OK, else error code */
704 
705 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20GetPTTKeyState(TiproHidDevice *device, int *nState);
706 /* Returns the state of the PTT key */
707 /* arguments (OUT) : state of the key (KEY_PRESSED / KEY_RELEASED) */
708 /* return value : command status : 0 == OK, else error code */
709 
710 /****************************************************************************/
711 /* BF22 FUNCTIONS */
712 /****************************************************************************/
713 
714 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetPCMScenario(TiproHidDevice *device, int nScenario);
715 /* Set PCM scenario */
716 /* arguments (IN) : PCM scenario (AB2LR / LR2LR) */
717 /* return value : command status : 0 == OK, else error code */
718 
719 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetPCMScenario(TiproHidDevice *device, int *nScenario, int *nInitScenario);
720 /* Get PCM scenario */
721 /* arguments (OUT) : PCM scenario (AB2LR / LR2LR) */
722 /* : Initial state from EEPROM */
723 /* return value : command status : 0 == OK, else error code */
724 
725 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMicAmpMode(TiproHidDevice *device, int nMicAmpMode);
726 /* Set Microphone amplifier mode (Linear/Logarithmic) */
727 /* arguments (IN) : Microphone amplifier mode (LIN/LOG) */
728 /* return value : command status : 0 == OK, else error code */
729 
730 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMicAmpMode(TiproHidDevice *device, int *nMicAmpMode, int *nInitMicAmpMode);
731 /* arguments (OUT) : Microphone amplifier mode (LIN/LOG) */
732 /* : Initial state from EEPROM */
733 /* return value : command status : 0 == OK, else error code */
734 
735 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetLFSpeakerState(TiproHidDevice *device, int nState);
736 /* Set LF speaker state (ON/OFF) */
737 /* arguments (IN) : LF speaker state (on/off) */
738 /* return value : command status : 0 == OK, else error code */
739 
740 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetLFSpeakerState(TiproHidDevice *device, int *nState, int *nInitState);
741 /* Get LF speaker state */
742 /* arguments (OUT) : LF speaker state (on/off) */
743 /* : Initial state from EEPROM */
744 /* return value : command status : 0 == OK, else error code */
745 
746 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMicOnVUState(TiproHidDevice *device, int nState);
747 /* Sets if microphone level is shown on the VU-meter (ON/OFF) */
748 /* arguments (IN) : microphone on VU-meter state (on/off) */
749 /* return value : command status : 0 == OK, else error code */
750 
751 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMicOnVUState(TiproHidDevice *device, int *nState, int *nInitState);
752 /* Get microphone level shown on VU-meter state */
753 /* arguments (OUT) : microphone level on VU-meter state (on/off) */
754 /* : Initial state from EEPROM */
755 /* return value : command status : 0 == OK, else error code */
756 
757 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMic2LineInState(TiproHidDevice *device, int nState);
758 /* Sets the connection state (ON/OFF) of the gooseneck microphone to the */
759 /* LINE-IN port on the motherboard */
760 /* arguments (IN) : connection state (ON/OFF) */
761 /* return value : command status : 0 == OK, else error code */
762 
763 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMic2LineInState(TiproHidDevice *device, int *nState, int *nInitState);
764 /* Returns the connection state (ON/OFF) of the gooseneck microphone to the */
765 /* LINE-IN port on the motherboard */
766 /* arguments (OUT) : connection state (ON/OFF) */
767 /* : initial state from EEPROM */
768 /* return value : command status : 0 == OK, else error code */
769 
770 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetLineOut2SpkMode(TiproHidDevice *device, int nMode);
771 /* Sets the connection mode (OFF/L/R/LR) of the motherboard LINE-OUT port */
772 /* to the speakers. */
773 /* arguments (IN) : connection mode (OFF/L/R/LR) */
774 /* return value : command status : 0 == OK, else error code */
775 
776 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetLineOut2SpkMode(TiproHidDevice *device, int *nMode, int *nInitMode);
777 /* Returns the connection mode (OFF/L/R/LR) of the motherboard LINE-OUT */
778 /* port to the speakers. */
779 /* arguments (OUT) : connection mode (OFF/L/R/LR) */
780 /* : initial state from EEPROM */
781 /* return value : command status : 0 == OK, else error code */
782 
783 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetEchoMode(TiproHidDevice *device, int nMode);
784 /* Sets the echo canceler mode (OFF/L/R/LR) */
785 /* arguments (IN) : echo canceler mode (OFF/L/R/LR) */
786 /* return value : command status : 0 == OK, else error code */
787 
788 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetEchoMode(TiproHidDevice *device, int *nMode, int *nInitMode);
789 /* Returns the echo canceler mode (OFF/L/R/LR) */
790 /* arguments (OUT) : echo canceler mode (OFF/L/R/LR) */
791 /* : initial state from EEPROM */
792 /* return value : command status : 0 == OK, else error code */
793 
794 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22TouchscreenDisable(TiproHidDevice *device);
795 /* Disables touchscreen */
796 /* return value : command status : 0 == OK, else error code */
797 
798 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22TouchscreenEnable(TiproHidDevice *device);
799 /* Enables touchscreen */
800 /* return value : command status : 0 == OK, else error code */
801 
802 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetPTTKeyLEDState(TiproHidDevice *device, int nState);
803 /* Sets the LED state of illuminated PTT key */
804 /* arguments (IN) : PTT LED state (PTT_LED_ON/PTT_LED_OFF/PTT_LED_BLINK) */
805 /* return value : command status : 0 == OK, else error code */
806 
807 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetPTTKeyLEDStateEx(TiproHidDevice *device, int nState, int nTBlinkOn, int nTBlinkOff);
808 /* Sets the operation of the illuminated PTT key with more paramters */
809 /* arguments (IN) : PTT LED state (PTT_LED_ON/PTT_LED_OFF/PTT_LED_BLINK) */
810 /* : On period for blink mode (ms) */
811 /* : Off period for blink mode (ms) */
812 /* return value : command status : 0 == OK, else error code */
813 
814 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetPTTKeyLEDState(TiproHidDevice *device, int *nState);
815 /* Returns the LED state of the illuminated PTT Key */
816 /* arguments (OUT) : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
817 /* return value : command status : 0 == OK, else error code */
818 
819 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22MuteMicrophone(TiproHidDevice *device, int nMute);
820 /* Mutes/un-mutes the microphone signal */
821 /* arguments (IN) : mute/un-mute microphone */
822 /* return value : command status : 0 == OK, else error code */
823 
824 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetLeftSpeakerLevel(TiproHidDevice *device, int nLevel);
825 /* Sets the level of the left speaker */
826 /* arguments (IN) : speaker level */
827 /* return value : command status : 0 == OK, else error code */
828 
829 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetLeftSpeakerLevel(TiproHidDevice *device, int *nLevel);
830 /* Returns the level of the left speaker */
831 /* arguments (OUT) : speaker level */
832 /* return value : command status : 0 == OK, else error code */
833 
834 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetRightSpeakerLevel(TiproHidDevice *device, int nLevel);
835 /* Sets the level of the right speaker */
836 /* arguments (IN) : speaker level */
837 /* return value : command status : 0 == OK, else error code */
838 
839 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetRightSpeakerLevel(TiproHidDevice *device, int *nLevel);
840 /* Returns the level of the right speaker */
841 /* arguments (OUT) : speaker level */
842 /* return value : command status : 0 == OK, else error code */
843 
844 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMicrophoneLevel(TiproHidDevice *device, int nLevel, bool bSetInit);
845 /* Sets the gooseneck microphone level */
846 /* arguments (IN) : microphone level */
847 /* : write initial state to EEPROM */
848 /* return value : command status : 0 == OK, else error code */
849 
850 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMicrophoneLevel(TiproHidDevice *device, int *nLevel, int *nInitLevel);
851 /* Returns the googeneck microphone level */
852 /* arguments (OUT) : microphone level */
853 /* : initial state from EEPROM */
854 /* return value : command status : 0 == OK, else error code */
855 
856 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMicrophoneOptimalDistance(TiproHidDevice *device, int nDistance, bool bSetInit);
857 /* Sets the microphone optimal distance */
858 /* arguments (IN) : microphone optimal distance */
859 /* : write initial state to EEPROM */
860 /* return value : command status : 0 == OK, else error code */
861 
862 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMicrophoneOptimalDistance(TiproHidDevice *device, int *nDistance, int *nInitDistance);
863 /* Gets the microphone optimal distance */
864 /* arguments (OUT) : microphone optimal distance */
865 /* : initial state from EEPROM */
866 /* return value : command status : 0 == OK, else error code */
867 
868 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMicrophoneThreshold(TiproHidDevice *device, int *nThreshold, int *nInitThreshold);
869 /* Returns threshold for the microphone signal */
870 /* arguments (OUT) : microphone threshold */
871 /* : initial state from EEPROM */
872 /* return value : command status : 0 == OK, else error code */
873 
874 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMicrophoneThreshold(TiproHidDevice *device, int nThreshold, bool bSetInit);
875 /* Sets threshold for the microphone signal */
876 /* arguments (IN) : microphone threshold */
877 /* : write initial state to EEPROM */
878 /* return value : command status : 0 == OK, else error code */
879 
880 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetMicrophoneCompression(TiproHidDevice *device, int *nCompression, int *nInitCompression);
881 /* Returns compression for the microphone signal */
882 /* arguments (OUT) : microphone compression */
883 /* : initial state from EEPROM */
884 /* return value : command status : 0 == OK, else error code */
885 
886 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetMicrophoneCompression(TiproHidDevice *device, int nCompression, bool bSetInit);
887 /* Sets compression for the microphone signal */
888 /* arguments (IN) : microphone compression */
889 /* : write initial state to EEPROM */
890 /* return value : command status : 0 == OK, else error code */
891 
892 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetLuminance(TiproHidDevice *device, int nLuminance);
893 /* Sets luminance for both stripe and LCD backlight */
894 /* arguments (IN) : luminance index (0-darkest; 20-brightest) */
895 /* return value : command status : 0 == OK, else error code */
896 
897 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetPTTKeyState(TiproHidDevice *device, int *nState);
898 /* Returns the state of the PTT key */
899 /* arguments (OUT) : state of the key (KEY_PRESSED / KEY_RELEASED) */
900 /* return value : command status : 0 == OK, else error code */
901 
902 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22SetLineKeysLedState(TiproHidDevice *device, int nKey1State, int nKey2State, int nKey3State, int nKey4State, int nKey5State, int nKey6State, int nKey7State, int nKey8State, int nKey9State, int nKey10State, int nKey11State, int nKey12State, int nKey13State, int nKey14State, int nKey15State, int nKey16State);
903 /* Sets the LED state for each key LED of Line-keys */
904 /* arguments (IN) : LED state (for each key - 16 keys) */
905 /* (BF22_LED_NOCHANGE/BF22_LED_OFF/BF22_LED_GREEN/BF22_LED_RED/BF22_LED_ORANGE/ */
906 /* BF22_LED_BLINK_OFF_GREEN/BF22_LED_BLINK_OFF_RED/BF22_LED_BLINK_OFF_ORANGE/ */
907 /* BF22_LED_BLINK_GREEN_OFF/BF22_LED_BLINK_GREEN_RED/BF22_LED_BLINK_GREEN_ORANGE/ */
908 /* BF22_LED_BLINK_RED_OFF/BF22_LED_BLINK_RED_GREEN/BF22_LED_BLINK_RED_ORANGE/ */
909 /* BF22_LED_BLINK_ORANGE_OFF/BF22_LED_BLINK_ORANGE_GREEN/BF22_LED_BLINK_ORANGE_RED)*/
910 /* return value : command status : 0 == OK, else error code */
911 
912 // int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22GetLineKeysLedState(TiproHidDevice *device, int *nKey1State, int *nKey2State, int *nKey3State, int *nKey4State, int *nKey5State, int *nKey6State, int *nKey7State, int *nKey8State, int *nKey9State, int *nKey10State, int *nKey11State, int *nKey12State, int *nKey13State, int *nKey14State, int *nKey15State, int *nKey16State);
913 /* Returns the LED state for each key LED of Line-keys */
914 /* arguments (OUT) : LED state (for each key - 16 keys) */
915 /* (BF22_LED_OFF/BF22_LED_GREEN/BF22_LED_RED/BF22_LED_ORANGE/ */
916 /* BF22_LED_BLINK_OFF_GREEN/BF22_LED_BLINK_OFF_RED/BF22_LED_BLINK_OFF_ORANGE/ */
917 /* BF22_LED_BLINK_GREEN_OFF/BF22_LED_BLINK_GREEN_RED/BF22_LED_BLINK_GREEN_ORANGE/ */
918 /* BF22_LED_BLINK_RED_OFF/BF22_LED_BLINK_RED_GREEN/BF22_LED_BLINK_RED_ORANGE/ */
919 /* BF22_LED_BLINK_ORANGE_OFF/BF22_LED_BLINK_ORANGE_GREEN/BF22_LED_BLINK_ORANGE_RED)*/
920 /* return value : command status : 0 == OK, else error code */
921 
922 
923 /****************************************************************************/
924 /* Handset functions */
925 /****************************************************************************/
926 
927 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetSetMicrophoneCompression (TiproHidDevice *device, int nHandsetNum, int nCompression);
928 /* Set compression for the microphone signal */
929 /* arguments (IN) : selected handset module number */
930 /* : microphone compression */
931 /* return value : command status : 0 == OK, else error code */
932 
933 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetSetMicrophoneThreshold (TiproHidDevice *device, int nHandsetNum, int nThreshold);
934 /* Set compression for the microphone signal */
935 /* arguments (IN) : selected handset module number */
936 /* : microphone threshold */
937 /* return value : command status : 0 == OK, else error code */
938 
939 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetSetMicrophoneLevel (TiproHidDevice *device, int nHandsetNum, int nLevel);
940 /* Set compression for the microphone signal */
941 /* arguments (IN) : selected handset module number */
942 /* : microphone level */
943 /* return value : command status : 0 == OK, else error code */
944 
945 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetGetMicrophoneCompression (TiproHidDevice *device, int nHandsetNum, int *nCompression);
946 /* Returns compression for the microphone signal */
947 /* arguments (IN) : selected handset module number */
948 /* arguments (OUT) : microphone compression */
949 /* return value : command status : 0 == OK, else error code */
950 
951 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetGetMicrophoneThreshold (TiproHidDevice *device, int nHandsetNum, int *nThreshold);
952 /* Returns compression for the microphone signal */
953 /* arguments (IN) : selected handset module number */
954 /* arguments (OUT) : microphone threshold */
955 /* return value : command status : 0 == OK, else error code */
956 
957 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetGetMicrophoneLevel (TiproHidDevice *device, int nHandsetNum, int *nLevel);
958 /* Returns compression for the microphone signal */
959 /* arguments (IN) : selected handset module number */
960 /* arguments (OUT) : microphone level */
961 /* return value : command status : 0 == OK, else error code */
962 
963 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetSetSpeakerLevel(TiproHidDevice *device, int nHandsetNum, int nLevel);
964 /* Sets the level of the handset speaker */
965 /* arguments (IN) : selected handset module number */
966 /* : speaker level */
967 /* return value : command status : 0 == OK, else error code */
968 
969 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDHandsetGetSpeakerLevel(TiproHidDevice *device, int nHandsetNum, int *nLevel);
970 /* Returns the level of the handset speaker */
971 /* arguments (OUT) : speaker level */
972 /* return value : command status : 0 == OK, else error code */
973 
974 
975 /****************************************************************************/
976 /* BF07 FUNCTIONS */
977 /****************************************************************************/
978 
979 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetSpeakerLevel(TiproHidDevice *device, int nLevel);
980 /* Sets the level of the speakers */
981 /* arguments (IN) : speaker level */
982 /* return value : command status : 0 == OK, else error code */
983 
984 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetSpeakerLevel(TiproHidDevice *device, int *nLevel);
985 /* Returns the level of the speakers */
986 /* arguments (IN) : speaker level */
987 /* return value : command status : 0 == OK, else error code */
988 
989 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetPTTLEDState(TiproHidDevice *device, int nState);
990 /* Sets the LED state of PTT key */
991 /* : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
992 /* return value : command status : 0 == OK, else error code */
993 
994 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetPTTLEDState(TiproHidDevice *device, int *nState);
995 /* Returns the LED state of the PTT key */
996 /* arguments (OUT) : state of the LED (LED_ON/LED_OFF/LED_BLINK) */
997 /* return value : command status : 0 == OK, else error code */
998 
999 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetHandsetSpeakerLevel(TiproHidDevice *device, int nLevel);
1000 /* Sets the level of the handset spekaer. */
1001 /* arguments (IN) : handset speaker level */
1002 /* return value : command status : 0 == OK, else error code */
1003 
1004 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetHandsetSpeakerLevel(TiproHidDevice *device, int *nLevel);
1005 /* Returns the current level of the handset speaker */
1006 /* arguments (OUT) : handset speaker level */
1007 /* return value : command status : 0 == OK, else error code */
1008 
1009 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetAlertLine(TiproHidDevice *device, int nMode);
1010 /* Sets the function (mode) of the alert line */
1011 /* arguments (IN) : mode (ALERT, VOICE, NOT USED) */
1012 /* return value : command status : 0 == OK, else error code */
1013 
1014 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetAlertLine(TiproHidDevice *device, int *nMode);
1015 /* returns the function (mode) of the alert line */
1016 /* arguments (OUT) : mode (ALERT, VOICE, NOT USED) */
1017 /* return value : command status : 0 == OK, else error code */
1018 
1019 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetMicrophoneLevel(TiproHidDevice *device, int nLevel, int nDevice);
1020 /* Sets the level of the microphone signal */
1021 /* arguments (IN) : microphone level */
1022 /* : device to set (handsfree, handset) */
1023 /* return value : command status : 0 == OK, else error code */
1024 
1025 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetMicrophoneLevel(TiproHidDevice *device, int *nLevel, int nDevice);
1026 /* Returns the level of microphone signal */
1027 /* arguments (OUT) : microphone level */
1028 /* arguments (IN) : device to get (handsfree, handset) */
1029 /* return value : command status : 0 == OK, else error code */
1030 
1031 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetMicrophoneThreshold(TiproHidDevice *device, int nThreshold, int nDevice);
1032 /* Sets the microphone threshold */
1033 /* arguments (IN) : microphone threshold */
1034 /* : device to set (handsfree, handset) */
1035 /* return value : command status : 0 == OK, else error code */
1036 
1037 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetMicrophoneThreshold(TiproHidDevice *device, int *nThreshold, int nDevice);
1038 /* Returns microphone threshold */
1039 /* arguments (IN) : microphone threshold */
1040 /* : device to get (handsfree, handset) */
1041 /* return value : command status : 0 == OK, else error code */
1042 
1043 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetMicrophoneCompression(TiproHidDevice *device, int nCompression, int nDevice);
1044 /* Sets the microphone compression */
1045 /* arguments (IN) : microphone compression */
1046 /* : device to set (handsfree, handset) */
1047 /* return value : command status : 0 == OK, else error code */
1048 
1049 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetMicrophoneCompression(TiproHidDevice *device, int *nCompression, int nDevice);
1050 /* Returns microphone compression */
1051 /* arguments (IN) : microphone compression */
1052 /* : device to set (handsfree, handset) */
1053 /* return value : command status : 0 == OK, else error code */
1054 
1055 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetMicrophoneOptimalDistance(TiproHidDevice *device, int nDistance, int nDevice);
1056 /* Sets the optimal distance for the microphone */
1057 /* arguments (IN) : microphone optimal distance */
1058 /* : device to set (handsfree, handset) */
1059 /* return value : command status : 0 == OK, else error code */
1060 
1061 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetMicrophoneOptimalDistance(TiproHidDevice *device, int *nDistance, int nDevice);
1062 /* Returns the optimal distance of the microphone */
1063 /* arguments (IN) : device to set (handsfree, handset) */
1064 /* arguments (OUT) : microphone optimal distance */
1065 /* return value : command status : 0 == OK, else error code */
1066 
1067 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetLEDBlinkSpeed(TiproHidDevice *device, int nTBlinkA, int nTBlinkB);
1068 /* Sets the LED blink timings */
1069 /* arguments (IN) : ON time in ms (1..65000) */
1070 /* : OFF time in ms (1..65000) */
1071 /* return value : command status : 0 == OK, else error code */
1072 
1073 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetLEDBlinkSpeed(TiproHidDevice *device, int *nTBlinkA, int *nTBlinkB);
1074 /* Get LED blink timings */
1075 /* arguments (IN) : selected speakerbox module number */
1076 /* arguments (OUT) : ON time in ms (1..65000) */
1077 /* : OFF time in ms (1..65000) */
1078 /* return value : command status : 0 == OK, else error code */
1079 
1080 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07TouchscreenDisable(TiproHidDevice *device);
1081 /* Disables touchscreen */
1082 /* return value : command status : 0 == OK, else error code */
1083 
1084 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07TouchscreenEnable(TiproHidDevice *device);
1085 /* Enables touchscreen */
1086 /* return value : command status : 0 == OK, else error code */
1087 
1088 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07DisableEcho(TiproHidDevice *device);
1089 /* Disables echo canceler */
1090 /* return value : command status : 0 == OK, else error code */
1091 
1092 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07EnableEcho(TiproHidDevice device);
1093 /* Enables echo canceler if present */
1094 /* return value : command status : 0 == OK, else error code */
1095 
1096 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetEchoState(TiproHidDevice *device, int *nState);
1097 /* Returns echo state */
1098 /* arguments (OUT) : echo state (ON/OFF/NOT_PRESENT) */
1099 /* return value : command status : 0 == OK, else error code */
1100 
1101 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetMicOnVUState(TiproHidDevice *device, int nState);
1102 /* Sets if microphone level is shown on the VU-meter (ON/OFF) */
1103 /* arguments (IN) : microphone on VU-meter state (ON/OFF) */
1104 /* return value : command status : 0 == OK, else error code */
1105 
1106 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetMicOnVUState(TiproHidDevice *device, int *nState);
1107 /* Returns if microphone level is shown on the VU-meter (ON/OFF) */
1108 /* arguments (OUT) : microphone on VU-meter state (ON/OFF) */
1109 /* return value : command status : 0 == OK, else error code */
1110 
1111 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetHandsetSidetoneLevel(TiproHidDevice *device, int nLevel);
1112 /* Sets the level of the handset sidetone */
1113 /* arguments (IN) : handset sidetone level */
1114 /* return value : command status : 0 == OK, else error code */
1115 
1116 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07SetHandsetSidetone(TiproHidDevice *device, bool bOn);
1117 /* Turn sidetone On or Off */
1118 /* arguments (IN) : handset On/Off */
1119 /* return value : command status : 0 == OK, else error code */
1120 
1121 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07GetHandsetSidetoneLevel(TiproHidDevice *device, int *nLevel);
1122 /* Returns the current level of the handset sidetone */
1123 /* arguments (OUT) : handset sidetone level */
1124 /* return value : command status : 0 == OK, else error code */
1125 
1126 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07EmulateKeyPress(TiproHidDevice *device, int nKey);
1127 /* Emulates handset or handsfree PTT key press */
1128 /* arguments (IN) : which key to "press" (HS_PTT, HF_PTT) */
1129 /* return value : command status : 0 == OK, else error code */
1130 
1131 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07EmulateKeyRelease(TiproHidDevice *device, int nKey);
1132 /* Emulates handset or handsfree PTT key release */
1133 /* arguments (IN) : which key to "press" (HS_PTT, HF_PTT) */
1134 /* return value : command status : 0 == OK, else error code */
1135 
1136 /****************************************************************************/
1137 /* SpeakerBox 104 functions */
1138 /****************************************************************************/
1139 // Audio output level functions
1140 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104SetAudioOutputLevel(TiproHidDevice *device, int nAudioOutput, int nLevel);
1141 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104GetAudioOutputLevel(TiproHidDevice *device, int nAudioOutput, int *nLevel);
1142 
1143 // LED controll functions
1144 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104SetLEDState(TiproHidDevice *device, int nLed, int nState);
1145 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104GetLEDState(TiproHidDevice *device, int nLed, int *nState);
1146 
1147 // Microphone controll functions
1148 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104SetMicrophoneThreshold(TiproHidDevice *device, int nThreshold);
1149 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104GetMicrophoneThreshold(TiproHidDevice *device, int *nThreshold);
1150 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104SetMicrophoneCompression(TiproHidDevice *device, int nCompression);
1151 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104GetMicrophoneCompression(TiproHidDevice *device, int *nCompression);
1152 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104SetMicrophonePreAmp(TiproHidDevice *device, int nPreAmp);
1153 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104GetMicrophonePreAmp(TiproHidDevice *device, int *nPreAmp);
1154 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104SetMicrophoneLevel(TiproHidDevice *device, int nLevel);
1155 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSBX104GetMicrophoneLevel(TiproHidDevice *device, int *nLevel);
1156 
1157 /****************************************************************************/
1158 /* HIDAPI telephony functions (HID telephony hardware required) */
1159 /****************************************************************************/
1160 
1161 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDDetectTelephonyDevices();
1162 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetNumOfDetectedTelephonyDevices();
1163 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetTelephonyDeviceProductString(USHORT hidIx, PVOID pString, ULONG lBufferLen);
1164 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetTelephonyDevice_VID_PID(USHORT hidIx, USHORT *nVID, USHORT *nPID);
1165 //20190709int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetTelephonyDeviceManufacturerString(USHORT hidIx, PVOID pString, ULONG lBufferLen);
1166 
1167 // currently not supported in hardware, not to be used
1168 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetTelephonyDeviceSNString(USHORT hidIx, PVOID pString, ULONG lBufferLen);
1169 
1170 
1171 //20190709 #if 1 // new combined function for registring callbacks
1172 #if 0
1173 // callback functions for returning pressed/released keys and status of the thread:
1174 //
1175 // fnCallback(USHORT nID, USHORT nUsagePage, USHORT nLinkUsage, USHORT nUsage, bool bPressed);
1176 //
1177 // Parameters:
1178 // nID; // ID of the telephony device (supporting more then one telephony devices on the same PC)
1179 // nUsagePage; // top collection usage page (for now always 0x0b = Telephony)
1180 // nLinkUsage; // usage of the specific link collection (0x01 = Phone, 0x06 = Key Pad, 0x07 = Progrmable Button)
1181 // nUsage; // usage at the specific collection
1182 // bPressed; // key pressed = TRUE or released = FALSE
1183 //
1184 // fnKeyStatusCallback(USHORT nID, int nStatus, int nErrCode, int nRFUParam);
1185 //
1186 // Parameters:
1187 // nID; // ID of the telephony device (supporting more then one telephony devices on the same PC)
1188 // nStatus; // Status of the thread ( to be defined later... for instance 0x00 = Stopped, 0x01 = Running ... )
1189 // nErrCode; // ErrCode for reported status ( to be defined later )
1190 // nRFUParam; // Reserved for future use ( to be defined later )
1191 //
1192 // fnKeyStatusCallback can be NULL if not needed
1193 //
1194 // If Visual Studio 2010 or later is used callback can be defined inside of the class using std:bind
1195 #if _MSC_VER > 1500
1196  #define _VARIADIC_MAX 10
1197  #include <functional>
1198  typedef std::function<int(USHORT,USHORT,USHORT,USHORT,bool)> tfnCallbackEx;
1199  typedef std::function<int(USHORT,int,int,int)> tfnThreadStatusEx;
1200  TIPROHIDAPI_API int HIDRegisterTelephonyCallbacksEx(USHORT hidIx, tfnCallbackEx fnKeyCallback, tfnThreadStatusEx fnKeyStatusCallback);
1201 #endif
1202 //
1203 // example how to register callback function that is part of a class:
1204 //
1205 // using namespace std::placeholders;
1206 // HIDRegisterTelephonyKeysCallbackEx(0,std::bind(&CExampleDlg::OnTelKeyPress,this,_1,_2,_3,_4,_5),NULL);
1207 //
1208 // else normal callback function defintion
1209 //20190709 typedef int (__stdcall *tfnCallback)(USHORT, USHORT, USHORT, USHORT, bool);
1210 //20190709 typedef int (__stdcall *tfnThreadStatus)(USHORT, int, int, int);
1211 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDRegisterTelephonyCallbacks(USHORT hidIx, tfnCallback fnKeyCallback, tfnThreadStatus fnKeyStatusCallback);
1212 
1213 #else
1214 // callback function for returning pressed/released keys: fnCallback(USHORT nID, USHORT nUsagePage, USHORT nLinkUsage, USHORT nUsage, bool bPressed);
1215 //
1216 // Parameters:
1217 // nID; // ID of the telephony device (supporting more then one telephony devices on the same PC)
1218 // nUsagePage; // top collection usage page (for now always 0x0b = Telephony)
1219 // nLinkUsage; // usage of the specific link collection (0x01 = Phone, 0x06 = Key Pad, 0x07 = Progrmable Button)
1220 // nUsage; // usage at the specific collection
1221 // bPressed; // key pressed = TRUE or released = FALSE
1222 //
1223 // If Visual Studio 2010 or later is used callback can be defined inside of the class using std:bind
1224 #if _MSC_VER > 1500
1225  #define _VARIADIC_MAX 10
1226  #include <functional>
1227  typedef std::function<int(USHORT,USHORT,USHORT,USHORT,bool)> tfnCallbackEx;
1228  TIPROHIDAPI_API int HIDRegisterTelephonyKeysCallbackEx(USHORT hidIx, tfnCallbackEx fnKeyCallback);
1229 #endif
1230 //
1231 // example how to register callback function that is part of a class:
1232 //
1233 // using namespace std::placeholders;
1234 // HIDRegisterTelephonyKeysCallbackEx(0,std::bind(&CExampleDlg::OnTelKeyPress,this,_1,_2,_3,_4,_5));
1235 //
1236 // else normal callback function defintion
1237 //20190709 typedef int (__stdcall *tfnCallback)(USHORT, USHORT, USHORT, USHORT, bool);
1238 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDRegisterTelephonyKeysCallback(USHORT hidIx, tfnCallback fnKeyCallback);
1239 
1240 
1241 // prepared for future development
1242 // callback function for returning status of the thread: fnThreadStatus(USHORT nID, int nStatus, int nErrCode, int nRFUParam);
1243 //
1244 // Parameters:
1245 // nID; // ID of the telephony device (supporting more then one telephony devices on the same PC)
1246 // nStatus; // Status of the thread ( to be defined later... for instance 0x00 = Stopped, 0x01 = Running ... )
1247 // nErrCode; // ErrCode for reported status ( to be defined later )
1248 // nRFUParam; // Reserved for future use ( to be defined later )
1249 // If Visual Studio 2010 or later is used callback can be defined inside of the class using std:bind
1250 #if _MSC_VER > 1500
1251  typedef std::function<int(USHORT,int,int,int)> tfnThreadStatusEx;
1252  TIPROHIDAPI_API int HIDRegisterTelephonyKeysStatusCallbackEx(USHORT hidIx, tfnThreadStatusEx fnKeyStatusCallback);
1253 #endif
1254 //20190709 typedef int (__stdcall *tfnThreadStatus)(USHORT, int, int, int);
1255 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDRegisterTelephonyKeysStatusCallback(USHORT hidIx, tfnThreadStatus fnKeyStatusCallback);
1256 #endif
1257 
1258 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDStopTelephonyKeyDevice(USHORT hidIx);
1259 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetTelephonyDevicePath(USHORT hidIx, PVOID pString, ULONG lBufferLen);
1260 
1261 
1262 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetModuleVersion(TiproHidDevice *device, int nIndex, unsigned char *nVerMaj, unsigned char *nVerMin, unsigned char *nVerBuild);
1263 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetModuleVersionEx(TiproHidDevice *device, int nIndex, unsigned char *nVerMaj, unsigned char *nVerMin, unsigned char *nVerBuild, unsigned char *nModuleType, unsigned char *nModuleID);
1264 
1265 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetControllerInfo(TiproHidDevice *device, int *nVerMaj, int *nVerMin, int *nVerBuild,int *nVerCustom, int *nFWLevel);
1266 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetManufacturerString(TiproHidDevice *device, void *pString, unsigned long ulBufferLen);
1267 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetProductString(TiproHidDevice *device, void *pString, unsigned long ulBufferLen);
1268 
1269 
1270 
1271 /*##PBP END*/
1272 
1273 /*********************** !!! REMOVE EVERYTHING BELOW THIS FROM RELEASE !!! ***************************************/
1274 
1275 /****************************************************************************/
1276 /* HIDAPI functions (FW Level 3 required) */
1277 /****************************************************************************/
1278 /* Not supported yet */
1279 
1280 
1281 // to be used only in ChangeMe
1282 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDEnableOptInterface(void);
1283 
1284 // in beta phase, but ready to be released
1285 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetStringDescriptor(ULONG lStrIx, PVOID pString, ULONG lBufferLen);
1286 //20190709 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetStringDescriptorEx(int hidIx, ULONG lStrIx, PVOID pString, ULONG lBufferLen );
1287 
1288 //#ifdef _VER_MULTIPLE_CONTROLLERS
1289 #if 1
1290 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetNumOfDetectedDevices();
1291 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSelectDeviceEx(int hidIx);
1292 #endif
1293 
1294 // additional functions for version 2.0. release ( check if they work, extend to HID Telephony if possible )
1295 #if 1
1296 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDGetSerialNumberString(void *pString, unsigned long ulBufferLen);
1297 #endif
1298 
1299 // internal function for future implementation of ChangeMe (somehow disable for releases)
1300 #if 1
1301 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDSendCommandRaw(int nAddress,int nCmd, unsigned char *pParameters, int nParLen, unsigned char *pResponse, int *nResLen);
1302 #endif
1303 
1304 // Testing functions
1305 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF20TestFunction();
1306 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22TestFunction();
1307 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF22BurnInFunction();
1308 int TIPROHIDAPI_API_EXPORT TIPROHIDAPI_API_CALL HIDBF07TestFunction();
1309 
1310 
1311 //20190709
1312 #ifdef __cplusplus
1313 }
1314 #endif
1315 
1316 #endif
1317 
1318 #endif
TiproHidDevice.h
Represents Tipro device.
CHM_ICON_DATA
Definition: Chameleon.h:44
CHM_BITMAP_DATA
Definition: Chameleon.h:24
TiproHidDevice
Definition: TiproHidDevice.h:29
CHM_BACKLIGHTING_DATA
Definition: Chameleon.h:50
Generated by   doxygen 1.8.13