| 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