Gocator API

- Home
- Categories
- Types
- Files

All Classes Files Functions Variables Typedefs Macros Groups Pages
GoSystem.h
Go to the documentation of this file.
1 /**
2 * @file GoSystem.h
3 * @brief Declares the GoSystem class.
4 *
5 * @internal
6 * Copyright (C) 2014 by LMI Technologies Inc.
7 * Licensed under the MIT License.
8 * Redistributed files must retain the above copyright notice.
9 */
10 #ifndef GO_SDK_SYSTEM_H
11 #define GO_SDK_SYSTEM_H
12
13 #include <GoSdk/GoSdkDef.h>
14 #include <GoSdk/GoSensor.h>
15 #include <GoSdk/GoMultiplexBank.h>
16
17 kBeginHeader()
18
19 /**
20 * @class GoSystem
21 * @extends kObject
22 * @ingroup GoSdk
23 * @brief Represents a system of Gocator devices.
24 *
25 * During construction, a GoSystem object uses Gocator Discovery Protocol to locate devices.
26 * Subsequently, the list of detected devices can be accessed using GoSystem_SensorCount and
27 * GoSystem_SensorAt.
28 *
29 * Immediately after construction, all sensor objects are in the <em>online</em> state. This state
30 * indicates that a sensor has been detected, but that the client has not yet established a control
31 * connection to the sensor. The only sensor functions than can be used in this state are GoSensor_State,
32 * GoSensor_Address, and GoSensor_SetAddress.
33 *
34 * Because Gocator Discovery Protocol works <em>across</em> subnets, but Gocator Control Protocol
35 * does not, it is possible for a sensor to be successfully detected but for subsequent connection
36 * attempts to fail. In this case, the GoSensor_SetAddress function can be used to reconfigure the
37 * sensor to operate on the same subnet as the client.
38 *
39 * If the client and device are configured to operate on the same subnet, the GoSystem_Connect or
40 * GoSensor_Connect functions can be used to establish control connections.
41 *
42 * @see GoSystem_Construct, GoSystem_Connect, GoSensor_State, GoSensor_Address, GoSensor_SetAddress.
43 */
44 typedef kObject GoSystem;
45
46 /** Defines the signature for a GoSystem data/health handler.
47 *
48 * NOTE: The GoDataSet received by this function must be destroyed after use,
49 * otherwise a memory leak will result.
50 *
51 * @see GoDestroy
52 */
53 typedef kStatus (kCall* GoDataFx)(kPointer context, GoSensor system, GoDataSet data);
54
55 /**
56 * Constructs a GoSystem object.
57 *
58 * During construction, a GoSystem object uses Gocator Discovery Protocol to locate sensors.
59 * The list of detected sensors can be accessed using the GoSystem_SensorCount and GoSystem_SensorAt
60 * functions.
61 *
62 * @public @memberof GoSystem
63 * @param system Receives constructed system object.
64 * @param allocator Memory allocator (or kNULL for default)
65 * @return Operation status.
66 */
67 GoFx(kStatus) GoSystem_Construct(GoSystem* system, kAlloc allocator);
68
69 /**
70 * Establishes control connections to all sensors.
71 *
72 * A control connection is required before calling any sensor function except GoSensor_State,
73 * GoSensor_Address, or GoSensor_SetAddress.
74 *
75 * @public @memberof GoSystem
76 * @param system GoSystem object.
77 * @return Operation status.
78 */
79 GoFx(kStatus) GoSystem_Connect(GoSystem system);
80
81 /**
82 * Terminates control connections to all sensors.
83 *
84 * @public @memberof GoSystem
85 * @param system GoSystem object.
86 * @return Operation status.
87 */
88 GoFx(kStatus) GoSystem_Disconnect(GoSystem system);
89
90 /**
91 * Reports whether the system has changes that require a refresh.
92 *
93 * Sensors can undergo autonomous state changes that require client state to be refreshed
94 * (e.g. sensor goes offline). The GoSystem_HasChanges function can be used to determine
95 * if such changes have occurred.
96 *
97 * The GoSystem_HasChanges function does not perform communication, and consequently, will not
98 * require the caller to block for a long duration. If changes are detected, the GoSystem_Refresh
99 * function can be called to resolve the changes.
100 *
101 * This method is thread-safe.
102 *
103 * @public @memberof GoSystem
104 * @param system GoSystem object.
105 * @return kTRUE if the system has changes.
106 */
107 GoFx(kBool) GoSystem_HasChanges(GoSystem system);
108
109 /**
110 * Updates client state to reflect any changes that have occurred in the sensor network.
111 *
112 * Sensors can undergo autonomous state changes that require client state to be refreshed
113 * (e.g. sensor goes offline). The GoSystem_Refresh function resynchronizes client state
114 * with the current state of the sensor network.
115 *
116 * Calling this function may destroy or modify local sensor objects. The GoSystem_HasChanges
117 * function can be used prior to calling GoSystem_Refresh, to determine whether a refresh is
118 * needed.
119 *
120 * @public @memberof GoSystem
121 * @param system GoSystem object.
122 * @return Operation status.
123 */
124 GoFx(kStatus) GoSystem_Refresh(GoSystem system);
125
126 /**
127 * Reports the Gocator Protocol version implemented by this library.
128 *
129 * A Gocator Protocol version number has a major component and a minor component.
130 * If the major version implemented by this library is the same as the major
131 * version implemented by a sensor device, then communication can proceed. Otherwise,
132 * the sensor should be upgraded or a newer version of this library should be obtained.
133 * Sensors with incompatible major versions will be reported as being in the
134 * <em>incompatible</em> state upon connection.
135 *
136 * If major versions match, but the minor version implemented by this library
137 * is lower than the minor version implemented by the sensor, then some sensor features
138 * will not be accessible through this library.
139 *
140 * If major versions match, but the minor version implemented by this library
141 * is higher than the minor version implemented by the sensor, then some features
142 * exposed by this library may be unimplemented by the sensor.
143 *
144 * This method is thread-safe.
145 *
146 * @public @memberof GoSystem
147 * @return Protocol version implemented by this library.
148 * @see GoSensor_ProtocolVersion, GoSensor_State
149 */
150 GoFx(kVersion) GoSystem_ProtocolVersion();
151
152 /**
153 * Reports the Gocator firmware version that was built alongside this library.
154 *
155 * A Gocator SDK version number has a major component and a minor component.
156 * If the major version implemented by this library is the same as the major
157 * version implemented by a sensor device, then communication can proceed. Otherwise,
158 * the sensor should be upgraded or a version of this library matching the sensor
159 * should be obtained.
160 *
161 * When it comes to the matter of mismatched SDK and firmware versions, so long
162 * as the protocol versions match up, they should be compatible.
163 *
164 * @public @memberof GoSystem
165 * @return Firmware version that was built alongside this library.
166 * @see GoSensor_FirmwareVersion, GoSystem_ProtocolVersion
167 */
168 GoFx(kVersion) GoSystem_SdkVersion();
169
170 /**
171 * Sets a callback function that can be used to receive sensor data messages asynchronously.
172 *
173 * Sensor data messages can be received synchronously using the GoSystem_ReceiveData function
174 * or asynchronously by registering a callback function. If a callback function is registered,
175 * a background thread will be created to perform notifications.
176 *
177 * To unregister a previously-registered data handler, call this function using kNULL in place
178 * of the callback function argument.
179 *
180 * @public @memberof GoSystem
181 * @param system GoSystem object.
182 * @param function Data callback function (or kNULL to unregister).
183 * @param receiver Receiver argument for callback.
184 * @return Operation status.
185 * @see GoDataFx, GoSystem_ReceiveData, GoSystem_SetDataCapacity, GoSystem_EnableData
186 */
187 GoFx(kStatus) GoSystem_SetDataHandler(GoSystem system, GoDataFx function, kPointer receiver);
188
189 /**
190 * Sets the maximum amount of memory that can be used to buffer received data messages.
191 *
192 * Received data messages are enqueued until they are accepted by the caller. This function
193 * determines the maximum size, in bytes, of enqueued messages. The default maximum size is 50 MB.
194 *
195 * @public @memberof GoSystem
196 * @param system GoSystem object.
197 * @param capacity Data queue capacity, in bytes.
198 * @return Operation status.
199 * @see GoSystem_DataCapacity
200 */
201 GoFx(kStatus) GoSystem_SetDataCapacity(GoSystem system, kSize capacity);
202
203 /**
204 * Reports that maximum amount of memory that can be used to buffer received data messages.
205 *
206 * @public @memberof GoSystem
207 * @param system GoSystem object.
208 * @return Data queue capacity, in bytes.
209 * @see GoSystem_SetDataCapacity
210 */
211 GoFx(kSize) GoSystem_DataCapacity(GoSystem system);
212
213 /**
214 * Establishes data connections to all connected sensors currently in the <em>ready</em> or <em>running</em> states.
215 *
216 * Data connections are not automatically established when sensor control connection are established.
217 * Use this function (or GoSensor_EnableData) to enable/disable data connections.
218 *
219 * @public @memberof GoSystem
220 * @param system GoSystem object.
221 * @param enable kTRUE to enable data connections; kFALSE to disable.
222 * @return Operation status.
223 * @see GoSystem_ReceiveData, GoSensor_EnableData
224 */
225 GoFx(kStatus) GoSystem_EnableData(GoSystem system, kBool enable);
226
227 /**
228 * Clears any buffered data messages.
229 *
230 * When stopping and then restarting a system, it may be desirable to ensure that no messages from
231 * the previous session remain in any buffers. The GoSystem_ClearData function closes any open data
232 * channels, destroys any received messages, and then reopens data channels.
233 *
234 * @public @memberof GoSystem
235 * @param system GoSystem object.
236 * @return Operation status.
237 */
238 GoFx(kStatus) GoSystem_ClearData(GoSystem system);
239
240 /**
241 * Receives a set of sensor data messages.
242 *
243 * Sensor data messages can be received synchronously using this function or asynchronously by
244 * registering a callback with the GoSystem_SetDataHandler function.
245 *
246 * NOTE: Data received with this function must be destroyed after use,
247 * otherwise a memory leak will result.
248 *
249 * @public @memberof GoSystem
250 * @param system GoSystem object.
251 * @param data Set of sensor data messages.
252 * @param timeout Duration to wait for messages, in microseconds.
253 * @return Operation status.
254 * @see GoDestroy, GoSystem_SetDataHandler, GoSystem_SetDataCapacity, GoSystem_EnableData
255 */
256 GoFx(kStatus) GoSystem_ReceiveData(GoSystem system, GoDataSet* data, k64u timeout);
257
258 /**
259 * Sets a callback function that can be used to receive sensor health messages asynchronously.
260 *
261 * Sensor health messages can be received synchronously using the GoSystem_ReceiveHealth function
262 * or asynchronously by registering a callback function. If a callback function is registered,
263 * a background thread will be created to perform notifications.
264 *
265 * To unregister a previously-registered health handler, call this function using kNULL in place
266 * of the callback function argument.
267 *
268 * @public @memberof GoSystem
269 * @param system GoSystem object.
270 * @param function Health callback function (or kNULL to unregister).
271 * @param receiver Receiver argument, passed to callback.
272 * @return Operation status.
273 * @see GoDataFx, GoSystem_ReceiveHealth, GoSystem_SetDataCapacity, GoSystem_EnableData
274 */
275 GoFx(kStatus) GoSystem_SetHealthHandler(GoSystem system, GoDataFx function, kPointer receiver);
276
277 /**
278 * Receives a set of sensor health messages.
279 *
280 * Sensor health messages can be received synchronously using this function or asynchronously by
281 * registering a callback with the GoSystem_SetHealthHandler function.
282 *
283 * @public @memberof GoSystem
284 * @param system GoSystem object.
285 * @param data Set of sensor health messages.
286 * @param timeout Duration to wait for messages, in microseconds.
287 * @return Operation status.
288 * @see GoSystem_SetHealthHandler
289 */
290 GoFx(kStatus) GoSystem_ReceiveHealth(GoSystem system, GoDataSet* data, k64u timeout);
291
292 /**
293 * Clears any buffered health messages.
294 *
295 * @public @memberof GoSystem
296 * @param system GoSystem object.
297 * @return Operation status.
298 */
299 GoFx(kStatus) GoSystem_ClearHealth(GoSystem system);
300
301 /**
302 * Starts all sensors that are currently in the <em>ready</em> state.
303 *
304 * @public @memberof GoSystem
305 * @param system GoSystem object.
306 * @return Operation status.
307 * @see GoSystem_Stop, GoSensor_Start, GoSensor_Stop
308 */
309 GoFx(kStatus) GoSystem_Start(GoSystem system);
310
311 /**
312 * Performs alignment for sensors in the <em>ready</em> state.
313 *
314 * NOTE: This operation will result in sensor starts for the duration of the
315 * alignment. It can be canceled via GoSystem_Stop. This function's operation
316 * status does not correspond to the actual alignment result. In order to
317 * retrieve the alignment result, you must enable the data channel before calling
318 * this function, receive an alignment data message and then check its status.
319 *
320 * @public @memberof GoSystem
321 * @param system GoSystem object.
322 * @return Operation status.
323 * @see GoSystem_EnableData, GoSystem_ReceiveData, GoSystem_Stop
324 */
325 GoFx(kStatus) GoSystem_StartAlignment(GoSystem system);
326
327 /**
328 * Performs exposure auto set for sensors in the <em>ready</em> state.
329 *
330 * NOTE: This operation will result in sensor starts for the duration of the
331 * exposure AutoSet. A successful operation status does NOT modify the configuration.
332 * You must retrieve the resulting exposure values and set it for the appropriate
333 * exposure setting. This involves enabling the data connection prior to running
334 * exposure auto set and then receiving an exposure auto set message, which
335 * you can then use to query the status and access the resulting value.
336 *
337 * @public @memberof GoSystem
338 * @param system GoSystem object.
339 * @return Operation status.
340 * @see GoSystem_EnableData, GoSystem_ReceiveData
341 */
342 GoFx(kStatus) GoSystem_StartExposureAutoSet(GoSystem system);
343
344 /**
345 * Stops all connected sensors.
346 *
347 * @public @memberof GoSystem
348 * @param system GoSystem object.
349 * @return Operation status.
350 * @see GoSystem_Start, GoSensor_Start, GoSensor_Stop
351 */
352 GoFx(kStatus) GoSystem_Stop(GoSystem system);
353
354
355 /**
356 * Reboots all connected sensors.
357 *
358 * @public @memberof GoSystem
359 * @param system GoSystem object.
360 * @param wait kTRUE to wait for reboot complete; kFALSE to return immediately.
361 * @return Operation status.
362 */
363 GoFx(kStatus) GoSystem_Reset(GoSystem system, kBool wait);
364
365 /**
366 * Aborts ongoing sensor communication.
367 *
368 * This method asynchronously aborts ongoing communication; the next time that any
369 * I/O operation blocks for an extended period of time, it will be terminated. This method
370 * is thread-safe.
371 *
372 * In order to resume communication, call GoSystem_Refresh or GoSystem_Connect.
373 *
374 * @public @memberof GoSystem
375 * @param system GoSystem object.
376 * @return Operation status.
377 */
378 GoFx(kStatus) GoSystem_Cancel(GoSystem system);
379
380 /**
381 * Gets the number of sensors in the system.
382 *
383 * @public @memberof GoSystem
384 * @param system GoSystem object.
385 * @return Count of sensors in the system.
386 * @see GoSystem_SensorAt
387 */
388 GoFx(kSize) GoSystem_SensorCount(GoSystem system);
389
390 /**
391 * Gets the sensor object at the specified index.
392 *
393 * @public @memberof GoSystem
394 * @param system GoSystem object.
395 * @param index Sensor index.
396 * @return Sensor object.
397 * @see GoSystem_SensorCount
398 */
399 GoFx(GoSensor) GoSystem_SensorAt(GoSystem system, kSize index);
400
401 /**
402 * Gets the sensor object with the specified device id (serial number).
403 *
404 * @public @memberof GoSystem
405 * @param system GoSystem object.
406 * @param id Device identifier.
407 * @param sensor Receives sensor object.
408 * @return Operation status (kERROR_NOT_FOUND if sensor not found).
409 * @see GoSystem_SensorCount, GoSystem_SensorAt
410 */
411 GoFx(kStatus) GoSystem_FindSensorById(GoSystem system, k32u id, GoSensor* sensor);
412
413 /**
414 * Gets the sensor object with the specified IP address.
415 *
416 * @public @memberof GoSystem
417 * @param system GoSystem object.
418 * @param address Pointer to sensor IP address.
419 * @param sensor Receives sensor object.
420 * @return Operation status (kERROR_NOT_FOUND if sensor not found).
421 * @see GoSystem_SensorCount, GoSystem_SensorAt
422 */
423 GoFx(kStatus) GoSystem_FindSensorByIpAddress(GoSystem system, const kIpAddress* address, GoSensor* sensor);
424
425 /**
426 * Gets the current time stamp from the sensor network.
427 *
428 * @public @memberof GoSystem
429 * @param system GoSystem object.
430 * @param time Receives current time stamp(microseconds).
431 * @return Operation status (kERROR_NOT_FOUND if no sensors available).
432 * @see GoSystem_GetEncoder
433 */
434 GoFx(kStatus) GoSystem_Timestamp(GoSystem system, k64u* time);
435
436 /**
437 * Gets the current encoder value from the sensor network.
438 *
439 * @public @memberof GoSystem
440 * @param system GoSystem object.
441 * @param encoder Receives current encoder value (ticks).
442 * @return Operation status (kERROR_NOT_FOUND if no sensors available).
443 * @see GoSystem_GetTime
444 */
445 GoFx(kStatus) GoSystem_Encoder(GoSystem system, k64s* encoder);
446
447 /**
448 * Gets the current multiplex bank count.
449 *
450 * @public @memberof GoSystem
451 * @param system GoSystem object.
452 * @return The current number of defined multiplex banks.
453 */
454 GoFx(kSize) GoSystem_MultiplexBankCount(GoSystem system);
455
456 /**
457 * Gets a multiplex bank corresponding to the given index.
458 *
459 * @public @memberof GoSystem
460 * @param system GoSystem object.
461 * @param index The index of the multiplex bank to retrieve.
462 * @return The multiplex bank at the given index or kNULL if an invalid index is given.
463 */
464 GoFx(GoMultiplexBank) GoSystem_MultiplexBankAt(GoSystem system, kSize index);
465
466 /**
467 * Adds a multiplex bank with a unique ID to the system.
468 *
469 * @public @memberof GoSystem
470 * @param system GoSystem object.
471 * @param bank A pointer to the newly created GoMultiplexBank object.
472 * @return Operation status.
473 */
474 GoFx(kStatus) GoSystem_AddMultiplexBank(GoSystem system, GoMultiplexBank* bank);
475
476 /**
477 * Removes a multiplex bank at the given index.
478 *
479 * @public @memberof GoSystem
480 * @param system GoSystem object.
481 * @param index The index of the multiplex bank to remove.
482 * @return Operation status.
483 */
484 GoFx(kStatus) GoSystem_RemoveMultiplexBank(GoSystem system, kSize index);
485
486 /**
487 * Removes all multiplex banks.
488 *
489 * @public @memberof GoSystem
490 * @param system GoSystem object.
491 * @return Operation status.
492 */
493 GoFx(kStatus) GoSystem_ClearMultiplexBanks(GoSystem system);
494
495 /**
496 * Gets the maximum sensor exposure duration in the given multiplex bank.
497 *
498 * @public @memberof GoSystem
499 * @param system GoSystem object.
500 * @param bank The multiplex bank to check.
501 * @return The maximum sensor exposure duration contained in the multiplexing bank.
502 */
503 GoFx(k64f) GoSystem_MaxBankExposureDuration(GoSystem system, GoMultiplexBank bank);
504
505 /**
506 * Automatically update the single multiplexing delay and period configuration for all sensors contained in all defined multiplex banks.
507 *
508 * @public @memberof GoSystem
509 * @param system GoSystem object.
510 * @param period The exposure period to set among all multiplexed sensors. A value of 0.0 will result in automatic period determination.
511 * @return Operation status.
512 */
513 GoFx(kStatus) GoSystem_UpdateAllMultiplexParameters(GoSystem system, k64f period);
514
515 /**
516 * Automatically update the multiplexing single delay configuration for all sensors contained in all defined multiplex banks.
517 *
518 * @public @memberof GoSystem
519 * @param system GoSystem object.
520 * @return Operation status.
521 */
522 GoFx(kStatus) GoSystem_UpdateMultiplexDelay(GoSystem system);
523
524 /**
525 * Returns the maximum value of all multiplexed sensor's minimum multiplexing periods.
526 *
527 * @public @memberof GoSystem
528 * @param system GoSystem object.
529 * @return Operation status.
530 */
531 GoFx(k64f) GoSystem_MaxMinimumMultiplexPeriod(GoSystem system);
532
533 /**
534 * Automatically update the multiplexing single period configuration for all sensors contained in all defined multiplex banks.
535 *
536 * @public @memberof GoSystem
537 * @param system GoSystem object.
538 * @param period The exposure period to set among all multiplexed sensors. A value of 0.0 will result in automatic period determination.
539 * @return Operation status.
540 */
541 GoFx(kStatus) GoSystem_UpdateMultiplexPeriod(GoSystem system, k64f period);
542
543 kEndHeader()
544 #include <GoSdk/GoSystem.x.h>
545
546 #endif
GoSystem
Represents a system of Gocator devices.
Definition: GoSystem.h:17
GoSystem::GoSystem_ReceiveHealth
kStatus GoSystem_ReceiveHealth(GoSystem system, GoDataSet *data, k64u timeout)
Receives a set of sensor health messages.
GoSystem::GoSystem_ClearMultiplexBanks
kStatus GoSystem_ClearMultiplexBanks(GoSystem system)
Removes all multiplex banks.
GoSystem::GoSystem_SensorCount
kSize GoSystem_SensorCount(GoSystem system)
Gets the number of sensors in the system.
GoSystem::GoSystem_ReceiveData
kStatus GoSystem_ReceiveData(GoSystem system, GoDataSet *data, k64u timeout)
Receives a set of sensor data messages.
GoSystem::GoSystem_Cancel
kStatus GoSystem_Cancel(GoSystem system)
Aborts ongoing sensor communication.
GoSystem::GoSystem_Stop
kStatus GoSystem_Stop(GoSystem system)
Stops all connected sensors.
GoSystem::GoSystem_SetHealthHandler
kStatus GoSystem_SetHealthHandler(GoSystem system, GoDataFx function, kPointer receiver)
Sets a callback function that can be used to receive sensor health messages asynchronously.
GoSensor.h
Declares the GoSensor class.
GoSystem::GoSystem_RemoveMultiplexBank
kStatus GoSystem_RemoveMultiplexBank(GoSystem system, kSize index)
Removes a multiplex bank at the given index.
GoSystem::GoSystem_StartExposureAutoSet
kStatus GoSystem_StartExposureAutoSet(GoSystem system)
Performs exposure auto set for sensors in the ready state.
GoMultiplexBank
Represents a bank of related sensors to be used in multiplexing.
Definition: GoMultiplexBank.h:16
GoSystem::GoSystem_SensorAt
GoSensor GoSystem_SensorAt(GoSystem system, kSize index)
Gets the sensor object at the specified index.
GoSystem::GoSystem_ClearData
kStatus GoSystem_ClearData(GoSystem system)
Clears any buffered data messages.
GoSystem::GoSystem_ProtocolVersion
kVersion GoSystem_ProtocolVersion()
Reports the Gocator Protocol version implemented by this library.
GoSdkDef.h
Essential SDK declarations.
GoSystem::GoSystem_Refresh
kStatus GoSystem_Refresh(GoSystem system)
Updates client state to reflect any changes that have occurred in the sensor network.
GoDataSet
Represents a collection of data channel or health channel messages.
Definition: GoDataSet.h:14
GoSystem::GoSystem_DataCapacity
kSize GoSystem_DataCapacity(GoSystem system)
Reports that maximum amount of memory that can be used to buffer received data messages.
GoSystem::GoSystem_SetDataCapacity
kStatus GoSystem_SetDataCapacity(GoSystem system, kSize capacity)
Sets the maximum amount of memory that can be used to buffer received data messages.
GoSystem::GoSystem_SetDataHandler
kStatus GoSystem_SetDataHandler(GoSystem system, GoDataFx function, kPointer receiver)
Sets a callback function that can be used to receive sensor data messages asynchronously.
GoSystem::GoSystem_UpdateAllMultiplexParameters
kStatus GoSystem_UpdateAllMultiplexParameters(GoSystem system, k64f period)
Automatically update the single multiplexing delay and period configuration for all sensors contained...
GoSystem::GoSystem_AddMultiplexBank
kStatus GoSystem_AddMultiplexBank(GoSystem system, GoMultiplexBank *bank)
Adds a multiplex bank with a unique ID to the system.
GoDataFx
kStatus(kCall * GoDataFx)(kPointer context, GoSensor system, GoDataSet data)
Defines the signature for a GoSystem data/health handler.
Definition: GoSystem.h:53
GoSystem::GoSystem_Disconnect
kStatus GoSystem_Disconnect(GoSystem system)
Terminates control connections to all sensors.
GoSystem::GoSystem_UpdateMultiplexPeriod
kStatus GoSystem_UpdateMultiplexPeriod(GoSystem system, k64f period)
Automatically update the multiplexing single period configuration for all sensors contained in all de...
GoSystem::GoSystem_Timestamp
kStatus GoSystem_Timestamp(GoSystem system, k64u *time)
Gets the current time stamp from the sensor network.
GoSystem::GoSystem_MaxMinimumMultiplexPeriod
k64f GoSystem_MaxMinimumMultiplexPeriod(GoSystem system)
Returns the maximum value of all multiplexed sensor's minimum multiplexing periods.
GoMultiplexBank.h
Declares the GoMultiplexBank class.
GoSystem::GoSystem_MultiplexBankAt
GoMultiplexBank GoSystem_MultiplexBankAt(GoSystem system, kSize index)
Gets a multiplex bank corresponding to the given index.
GoSystem::GoSystem_MultiplexBankCount
kSize GoSystem_MultiplexBankCount(GoSystem system)
Gets the current multiplex bank count.
kBeginHeader
kBeginHeader() kStatus GoSdk_Construct(kAssembly *assembly)
Constructs the Gocator SDK library.
GoSystem::GoSystem_HasChanges
kBool GoSystem_HasChanges(GoSystem system)
Reports whether the system has changes that require a refresh.
GoSystem::GoSystem_EnableData
kStatus GoSystem_EnableData(GoSystem system, kBool enable)
Establishes data connections to all connected sensors currently in the ready or running states...
GoSystem::GoSystem_FindSensorById
kStatus GoSystem_FindSensorById(GoSystem system, k32u id, GoSensor *sensor)
Gets the sensor object with the specified device id (serial number).
GoSystem::GoSystem_UpdateMultiplexDelay
kStatus GoSystem_UpdateMultiplexDelay(GoSystem system)
Automatically update the multiplexing single delay configuration for all sensors contained in all def...
GoSystem::GoSystem_MaxBankExposureDuration
k64f GoSystem_MaxBankExposureDuration(GoSystem system, GoMultiplexBank bank)
Gets the maximum sensor exposure duration in the given multiplex bank.
GoSystem::GoSystem_Connect
kStatus GoSystem_Connect(GoSystem system)
Establishes control connections to all sensors.
GoSystem::GoSystem_Encoder
kStatus GoSystem_Encoder(GoSystem system, k64s *encoder)
Gets the current encoder value from the sensor network.
GoSystem::GoSystem_StartAlignment
kStatus GoSystem_StartAlignment(GoSystem system)
Performs alignment for sensors in the ready state.
GoSystem::GoSystem_Construct
kStatus GoSystem_Construct(GoSystem *system, kAlloc allocator)
Constructs a GoSystem object.
GoSystem::GoSystem_Reset
kStatus GoSystem_Reset(GoSystem system, kBool wait)
Reboots all connected sensors.
GoSystem::GoSystem_SdkVersion
kVersion GoSystem_SdkVersion()
Reports the Gocator firmware version that was built alongside this library.
GoSystem::GoSystem_FindSensorByIpAddress
kStatus GoSystem_FindSensorByIpAddress(GoSystem system, const kIpAddress *address, GoSensor *sensor)
Gets the sensor object with the specified IP address.
GoSystem::GoSystem_Start
kStatus GoSystem_Start(GoSystem system)
Starts all sensors that are currently in the ready state.
GoSensor
Represents a Gocator sensor.
Definition: GoSensor.h:21
GoSystem::GoSystem_ClearHealth
kStatus GoSystem_ClearHealth(GoSystem system)
Clears any buffered health messages.