Time-of-Flight Library(ToF) 3.13.4
 
gige_interface.h
1#ifndef _CHRONOPTICS_TOF_GIGE_INTERFACE_H_
2#define _CHRONOPTICS_TOF_GIGE_INTERFACE_H_
3
4#include <chronoptics/tof/camera_config.h>
5#include <chronoptics/tof/calibration.h>
6#include <chronoptics/tof/data.h>
7
8#ifdef __cplusplus
9extern "C" {
10#endif
11
12/** The possible depth streams that can be streamed from the camera
13 */
14enum tof_depth_stream_type {
15 TOF_DEPTH_STREAM_TYPE_RAW = 0, /** Stream raw data */
16 TOF_DEPTH_STREAM_TYPE_RADIAL_INTENSITY = 1, /** Stream both radial and intensity */
17 TOF_DEPTH_STREAM_TYPE_RADIAL = 2, /** Stream radial */
18 TOF_DEPTH_STREAM_TYPE_INTENSITY = 3, /** Stream intensity */
19};
20
21/** A gige discovery message containing camera information
22 */
23typedef struct tof_discovery_message* tof_discovery_message_t;
24
25/** Destruct tof_discovery_message */
26TOF_EXPORT void tof_discovery_message_delete(tof_discovery_message_t ptr);
27
28/** Get the camera's ip address
29 * @param ptr Pointer to class
30 * @param error Pointer to error
31 * @return Ip address
32 */
33TOF_EXPORT const char* tof_discovery_message_ip(const tof_discovery_message_t ptr, tof_error_t *error);
34
35/** Get the camera's serial
36 * @param ptr Pointer to class
37 * @param error Pointer to error
38 * @return Serial
39 */
40TOF_EXPORT const char* tof_discovery_message_serial(const tof_discovery_message_t ptr, tof_error_t *error);
41
42/** A persistent ip data structure
43 */
44typedef struct tof_persistent_ip* tof_persistent_ip_t;
45
46/** Destruct tof_persistent_ip */
47TOF_EXPORT void tof_persistent_ip_delete(tof_persistent_ip_t ptr);
48
49/** Create persistent ip
50 * @param ptr Pointer to class
51 * @param ip IP address
52 * @param netmask Netmask
53 * @param gateway Gateway
54 * @param enabled Enable or disable persistent ip
55 * @param error Pointer to error
56 * @return New object
57 */
58TOF_EXPORT tof_persistent_ip_t tof_persistent_ip_new(const char* ip, const char* netmask, const char* gateway, bool enabled, tof_error_t *error);
59
60/** Get the IP address
61 * @param ptr Pointer to class
62 * @param error Pointer to error
63 * @return the IP address
64 */
65TOF_EXPORT const char* tof_persistent_ip_get_ip(const tof_persistent_ip_t ptr, tof_error_t *error);
66
67/** Set the IP address
68 * @param ptr Pointer to class
69 * @param ip the IP address
70 * @param error Pointer to error
71 */
72TOF_EXPORT void tof_persistent_ip_set_ip(tof_persistent_ip_t ptr, const char* ip, tof_error_t *error);
73
74/** Get the netmask
75 * @param ptr Pointer to class
76 * @param error Pointer to error
77 * @return The netmask
78 */
79TOF_EXPORT const char* tof_persistent_ip_get_netmask(const tof_persistent_ip_t ptr, tof_error_t *error);
80
81/** Set the netmask
82 * @param ptr Pointer to class
83 * @param netmask The netmask
84 * @param error Pointer to error
85 */
86TOF_EXPORT void tof_persistent_ip_set_netmask(tof_persistent_ip_t ptr, const char* netmask, tof_error_t *error);
87
88/** Get the gateway
89 * @param ptr Pointer to class
90 * @param error Pointer to error
91 * @return The gateway
92 */
93TOF_EXPORT const char* tof_persistent_ip_get_gateway(const tof_persistent_ip_t ptr, tof_error_t *error);
94
95/** Set the gateway
96 * @param ptr Pointer to class
97 * @param gateway The gateway
98 * @param error Pointer to error
99 */
100TOF_EXPORT void tof_persistent_ip_set_gateway(tof_persistent_ip_t ptr, const char* gateway, tof_error_t *error);
101
102/** Get if persistent ip is enabled
103 * @param ptr Pointer to class
104 * @param error Pointer to error
105 * @return Is enabled
106 */
107TOF_EXPORT bool tof_persistent_ip_get_enabled(const tof_persistent_ip_t ptr, tof_error_t *error);
108
109/** Set if persistent ip is enabled
110 * @param ptr Pointer to class
111 * @param enabled Is enabled
112 * @param error Pointer to error
113 */
114TOF_EXPORT void tof_persistent_ip_set_enabled(tof_persistent_ip_t ptr, bool enabled, tof_error_t *error);
115
116/** DEPRECATED, use KeaCamera. Connect to a camera directly using the gige
117 * interface
118 */
119typedef struct tof_gige_interface* tof_gige_interface_t;
120
121/** Destruct tof_gige_interface */
122TOF_EXPORT void tof_gige_interface_delete(tof_gige_interface_t ptr);
123
124/** Create an instance of the gige interface
125 * @param ptr Pointer to class
126 * @param port The port to use for GVCP communication, if 0 is specified it will
127 * use an OS assigned port
128 * @param error Pointer to error
129 * @return New object
130 */
131TOF_EXPORT tof_gige_interface_t tof_gige_interface_new(uint16_t port, tof_error_t *error);
132
133/** Detect all the cameras on the network
134 * @param ptr Pointer to class
135 * @param messages A list of discovery messages
136 * @param capacity The amount of data the above pointer can hold
137 * @param error Pointer to error
138 * @return Number of pointers filled or complete array size
139 */
140TOF_EXPORT size_t tof_gige_interface_discover(tof_gige_interface_t ptr, tof_discovery_message_t* messages, size_t capacity, tof_error_t *error);
141
142/** Returns a message of the first camera that responded
143 * @param ptr Pointer to class
144 * @param error Pointer to error
145 * @return A discovery message
146 */
147TOF_EXPORT tof_discovery_message_t tof_gige_interface_discover_one(tof_gige_interface_t ptr, tof_error_t *error);
148
149/** Detect a specific camera on the network, will throw an error if it can't
150 * find the camera
151 * @param ptr Pointer to class
152 * @param serial Serial number of camera to find
153 * @param error Pointer to error
154 * @return A discovery message
155 */
156TOF_EXPORT tof_discovery_message_t tof_gige_interface_find(tof_gige_interface_t ptr, const char* serial, tof_error_t *error);
157
158/** Connect to the camera and gain exclusive access
159 * @param ptr Pointer to class
160 * @param message Discovery message of the camera to connect to
161 * @param error Pointer to error
162 */
163TOF_EXPORT void tof_gige_interface_connect(tof_gige_interface_t ptr, const tof_discovery_message_t message, tof_error_t *error);
164
165/** Disconnect from the camera
166 * @param ptr Pointer to class
167 * @param error Pointer to error
168 */
169TOF_EXPORT void tof_gige_interface_disconnect(tof_gige_interface_t ptr, tof_error_t *error);
170
171/** Check whether a connection is still maintained with the camera
172 * @param ptr Pointer to class
173 * @param error Pointer to error
174 * @return Is connected
175 */
176TOF_EXPORT bool tof_gige_interface_is_connected(const tof_gige_interface_t ptr, tof_error_t *error);
177
178/** Get stream packet size
179 * @param ptr Pointer to class
180 * @param error Pointer to error
181 * @return The packet size
182 */
183TOF_EXPORT uint16_t tof_gige_interface_get_stream_packet_size(const tof_gige_interface_t ptr, tof_error_t *error);
184
185/** Set stream packet size
186 * @param ptr Pointer to class
187 * @param packet_size The packet size
188 * @param error Pointer to error
189 */
190TOF_EXPORT void tof_gige_interface_set_stream_packet_size(tof_gige_interface_t ptr, uint16_t packet_size, tof_error_t *error);
191
192/** Test whether using the set packet size works
193 * @param ptr Pointer to class
194 * @param port Port to send test packets to
195 * @param error Pointer to error
196 * @return Packet size works
197 */
198TOF_EXPORT bool tof_gige_interface_test_stream_packet_size(tof_gige_interface_t ptr, uint16_t port, tof_error_t *error);
199
200/** Get delay between network packets
201 * @param ptr Pointer to class
202 * @param error Pointer to error
203 * @return The delay, depending on the camera software it is in nanoseconds or
204 * in cpu instruction
205 */
206TOF_EXPORT uint32_t tof_gige_interface_get_delay(const tof_gige_interface_t ptr, tof_error_t *error);
207
208/** Set delay between network packets
209 * @param ptr Pointer to class
210 * @param delay The delay, depending on the camera software it is in nanoseconds
211 * or in cpu instruction
212 * @param error Pointer to error
213 */
214TOF_EXPORT void tof_gige_interface_set_delay(tof_gige_interface_t ptr, uint32_t delay, tof_error_t *error);
215
216/** Download camera configuration from the camera
217 * @param ptr Pointer to class
218 * @param port Port to download configuration on
219 * @param error Pointer to error
220 * @return Camera configuration
221 */
222TOF_EXPORT tof_camera_config_t tof_gige_interface_download_configuration(tof_gige_interface_t ptr, uint16_t port, tof_error_t *error);
223
224/** Download calibration from the camera
225 * @param ptr Pointer to class
226 * @param port Port to download configuration on
227 * @param error Pointer to error
228 * @return Calibration
229 */
230TOF_EXPORT tof_calibration_t tof_gige_interface_download_calibration(tof_gige_interface_t ptr, uint16_t port, tof_error_t *error);
231
232/** Upload camera configuration to the camera
233 * @param ptr Pointer to class
234 * @param config Camera configuration
235 * @param port Port to download configuration on
236 * @param error Pointer to error
237 */
238TOF_EXPORT void tof_gige_interface_upload_configuration(tof_gige_interface_t ptr, const tof_camera_config_t config, uint16_t port, tof_error_t *error);
239
240/** Check whether this camera is capable of streaming the specified type
241 * @param ptr Pointer to class
242 * @param stream Depth stream type
243 * @param error Pointer to error
244 * @return Is capable
245 */
246TOF_EXPORT bool tof_gige_interface_depth_stream_capable(const tof_gige_interface_t ptr, enum tof_depth_stream_type stream, tof_error_t *error);
247
248/** Start the depth stream
249 * @param ptr Pointer to class
250 * @param stream Depth stream type
251 * @param port Port to receive depth data on
252 * @param error Pointer to error
253 */
254TOF_EXPORT void tof_gige_interface_start_depth_stream(tof_gige_interface_t ptr, enum tof_depth_stream_type stream, uint16_t port, tof_error_t *error);
255
256/** Stop the depth stream
257 * @param ptr Pointer to class
258 * @param error Pointer to error
259 */
260TOF_EXPORT void tof_gige_interface_stop_depth_stream(tof_gige_interface_t ptr, tof_error_t *error);
261
262/** Returns true if a depth frame is available
263 * @param ptr Pointer to class
264 * @param error Pointer to error
265 * @return Depth frame available
266 */
267TOF_EXPORT bool tof_gige_interface_has_depth_data(const tof_gige_interface_t ptr, tof_error_t *error);
268
269/** Get a depth frame
270 * @param ptr Pointer to class
271 * @param error Pointer to error
272 * @return Depth frame
273 */
274TOF_EXPORT tof_data_t tof_gige_interface_get_depth_data(tof_gige_interface_t ptr, tof_error_t *error);
275
276/** Check whether camera supports an image stream
277 * @param ptr Pointer to class
278 * @param error Pointer to error
279 * @return Camera supports an image stream
280 */
281TOF_EXPORT bool tof_gige_interface_image_stream_capable(const tof_gige_interface_t ptr, tof_error_t *error);
282
283/** Start image stream
284 * @param ptr Pointer to class
285 * @param port Port to receive image data on
286 * @param error Pointer to error
287 */
288TOF_EXPORT void tof_gige_interface_start_image_stream(tof_gige_interface_t ptr, uint16_t port, tof_error_t *error);
289
290/** Stop image stream
291 * @param ptr Pointer to class
292 * @param error Pointer to error
293 */
294TOF_EXPORT void tof_gige_interface_stop_image_stream(tof_gige_interface_t ptr, tof_error_t *error);
295
296/** Check whether image frame is available
297 * @param ptr Pointer to class
298 * @param error Pointer to error
299 * @return Image frame available
300 */
301TOF_EXPORT bool tof_gige_interface_has_image_data(const tof_gige_interface_t ptr, tof_error_t *error);
302
303/** Get image frame
304 * @param ptr Pointer to class
305 * @param error Pointer to error
306 * @return Image data
307 */
308TOF_EXPORT tof_data_t tof_gige_interface_get_image_data(tof_gige_interface_t ptr, tof_error_t *error);
309
310/** Get the image frame into the supplied pointer
311 * @param ptr Pointer to class
312 * @param pointer The pointer to the data to write into
313 * @param capacity The amount of data the pointer can hold
314 * @param callback Callback that will be called when pointer is no longer in use
315 * @param callback_user_data User data that will be passed back when the function pointer is called
316 * @param error Pointer to error
317 * @return Image data
318 */
319TOF_EXPORT tof_data_t tof_gige_interface_get_image_data_into_pointer(tof_gige_interface_t ptr, uint8_t* pointer, size_t capacity, tof_user_pointer_destructed_t callback, void* callback_user_data, tof_error_t *error);
320
321/** Get whether the camera is persistent ip capable
322 * @param ptr Pointer to class
323 * @param error Pointer to error
324 * @return Persistent IP capable
325 */
326TOF_EXPORT bool tof_gige_interface_persistent_ip_capable(const tof_gige_interface_t ptr, tof_error_t *error);
327
328/** Get the current persistent ip settings
329 * @param ptr Pointer to class
330 * @param error Pointer to error
331 * @return Persistent IP
332 */
333TOF_EXPORT tof_persistent_ip_t tof_gige_interface_get_persistent_ip(const tof_gige_interface_t ptr, tof_error_t *error);
334
335/** Set the persistent ip settings. The persistent ip settings will be active on
336 * next reboot.
337 * @param ptr Pointer to class
338 * @param persistent_ip The persistent ip
339 * @param error Pointer to error
340 */
341TOF_EXPORT void tof_gige_interface_set_persistent_ip(tof_gige_interface_t ptr, const tof_persistent_ip_t persistent_ip, tof_error_t *error);
342
343/** Get the capacity for amount of user pointers that can be registered
344 * @param ptr Pointer to class
345 * @param error Pointer to error
346 * @return User pointer capacity
347 */
348TOF_EXPORT size_t tof_gige_interface_get_user_pointer_capacity(const tof_gige_interface_t ptr, tof_error_t *error);
349
350/** Set the capacity for amount of user pointers that can be registered
351 * @param ptr Pointer to class
352 * @param capacity User pointer capacity
353 * @param error Pointer to error
354 */
355TOF_EXPORT void tof_gige_interface_set_user_pointer_capacity(tof_gige_interface_t ptr, size_t capacity, tof_error_t *error);
356
357/** Add a pointer that will be filled with depth data. This method allows you to
358 * fill data straight into your own data structure without any additional
359 * copying.
360 * @param ptr Pointer to class
361 * @param pointer The pointer to the data to write into
362 * @param capacity The amount of data the pointer can hold
363 * @param callback Callback that will be called when pointer is no longer in use
364 * @param callback_user_data User data that will be passed back when the function pointer is called
365 * @param error Pointer to error
366 */
367TOF_EXPORT void tof_gige_interface_add_depth_user_pointer(tof_gige_interface_t ptr, uint8_t* pointer, size_t capacity, tof_user_pointer_destructed_t callback, void* callback_user_data, tof_error_t *error);
368
369/** Get the tof library version running on the camera
370 * @param ptr Pointer to class
371 * @param error Pointer to error
372 * @return Version
373 */
374TOF_EXPORT const char* tof_gige_interface_version(tof_gige_interface_t ptr, tof_error_t *error);
375
376/** Check whether the camera is capable of software trigger
377 * @param ptr Pointer to class
378 * @param error Pointer to error
379 * @return Software trigger capable
380 */
381TOF_EXPORT bool tof_gige_interface_software_trigger_capable(tof_gige_interface_t ptr, tof_error_t *error);
382
383/** Software trigger the camera
384 * @param ptr Pointer to class
385 * @param error Pointer to error
386 */
387TOF_EXPORT void tof_gige_interface_software_trigger(tof_gige_interface_t ptr, tof_error_t *error);
388
389#ifdef __cplusplus
390}
391#endif
392
393#endif