AFBR-S50 API Reference Manual v1.6.6
AFBR-S50 Time-of-Flight Sensor SDK for Embedded Software
Loading...
Searching...
No Matches
argus_api.h
Go to the documentation of this file.
1/*************************************************************************/
38#ifndef ARGUS_API_H
39#define ARGUS_API_H
40#ifdef __cplusplus
41extern "C" {
42#endif
43
44/*!***************************************************************************
45 * @defgroup argus_api AFBR-S50 API
46 * @ingroup argus
47 *
48 * @brief The main module of the API from the AFBR-S50 SDK.
49 *
50 * @details General API for the AFBR-S50 time-of-flight sensor device family.\n
51 * See the \ref getting_started Guide for a detailed description
52 * on how to use the module/API.
53 *
54 * @addtogroup argus_api
55 * @{
56 *****************************************************************************/
57
58#include "argus_def.h"
59#include "argus_res.h"
60#include "argus_pba.h"
61#include "argus_dfm.h"
62#include "argus_nd.h"
63#include "argus_snm.h"
64#include "argus_xtalk.h"
65#include "argus_offset.h"
66
68typedef int32_t s2pi_slave_t;
69
70/*!***************************************************************************
71 * @brief Initializes the device with default measurement mode.
72 *
73 * @details The function that needs to be called once after power up to
74 * initialize the modules state (i.e. the corresponding handle) and the
75 * dedicated Time-of-Flight device. In order to obtain a handle,
76 * reference the #Argus_CreateHandle method.
77 *
78 * Prior to calling the function, the required peripherals (i.e. S2PI,
79 * GPIO w/ IRQ and Timers) must be initialized and ready to use.
80 *
81 * The function executes the following tasks:
82 * - Initialization of the internal state represented by the handle
83 * object.
84 * - Setup the device such that an safe configuration is present in
85 * the registers.
86 * - Initialize sub modules such as calibration or measurement modules.
87 * .
88 *
89 * The modules configuration is initialized with reasonable default
90 * values. Note that the default measurement mode depends on the
91 * given device.
92 *
93 * Also refer to #Argus_InitMode, which uses an specified measurement
94 * mode instead of the dedicated default measurement mode.
95 *
96 * @param hnd The API handle; contains all internal states and data.
97 *
98 * @param spi_slave The SPI hardware slave, i.e. the specified CS and IRQ
99 * lines. This is actually just a number that is passed
100 * to the SPI interface to distinct for multiple SPI slave
101 * devices. Note that the slave must be not equal to 0,
102 * since is reserved for error handling.
103 *
104 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
105 *****************************************************************************/
106status_t Argus_Init(argus_hnd_t * hnd, s2pi_slave_t spi_slave);
107
108/*!***************************************************************************
109 * @brief Initializes the device with specified measurement mode.
110 *
111 * @details The function that needs to be called once after power up to
112 * initialize the modules state (i.e. the corresponding handle) and the
113 * dedicated Time-of-Flight device. In order to obtain a handle,
114 * reference the #Argus_CreateHandle method.
115 *
116 * Prior to calling the function, the required peripherals (i.e. S2PI,
117 * GPIO w/ IRQ and Timers) must be initialized and ready to use.
118 *
119 * The function executes the following tasks:
120 * - Initialization of the internal state represented by the handle
121 * object.
122 * - Setup the device such that an safe configuration is present in
123 * the registers.
124 * - Initialize sub modules such as calibration or measurement modules.
125 * .
126 *
127 * The modules configuration is initialized with reasonable default values.
128 *
129 * Also refer to #Argus_Init, which uses the dedicated default measurement
130 * mode instead of an user specified measurement mode.
131 *
132 * @param hnd The API handle; contains all internal states and data.
133 *
134 * @param spi_slave The SPI hardware slave, i.e. the specified CS and IRQ
135 * lines. This is actually just a number that is passed
136 * to the SPI interface to distinct for multiple SPI slave
137 * devices. Note that the slave must be not equal to 0,
138 * since is reserved for error handling.
139 *
140 * @param mode The specified measurement mode to be initialized.
141 * Pass 0 as special value to select default measurement mode
142 * (see #Argus_Init).
143 *
144 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
145 *****************************************************************************/
146status_t Argus_InitMode(argus_hnd_t * hnd, s2pi_slave_t spi_slave, argus_mode_t mode);
147
148/*!***************************************************************************
149 * @brief Reinitializes the device with the current measurement mode.
150 *
151 * @details The function reinitializes the device with the currently active
152 * measurement mode.
153 *
154 * This can be used as a soft reset for the device and API.
155 * See #Argus_Init for more information on the initialization.
156 *
157 * Note that the #Argus_Init or #Argus_InitMode function must be called
158 * first! Otherwise, the function will return an error if it is called
159 * for an yet uninitialized device/handle.
160 *
161 * Also refer to #Argus_ReinitMode, which uses a specified measurement
162 * mode instead of the currently active measurement mode.
163 *
164 * @note If a full re-initialization is not desired, refer to the
165 * #Argus_RestoreDeviceState function that will only re-write the
166 * register map to the device to restore its state after an power
167 * cycle.
168 *
169 * @param hnd The API handle; contains all internal states and data.
170 *
171 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
172 *****************************************************************************/
173status_t Argus_Reinit(argus_hnd_t * hnd);
174
175/*!***************************************************************************
176 * @brief Reinitializes the device with a specified measurement mode.
177 *
178 * @details The function reinitializes the device with a specified (/p mode)
179 * measurement mode.
180 *
181 * This can be used as a soft reset for the device and API.
182 * See #Argus_InitMode for more information on the initialization.
183 *
184 * Note that the #Argus_Init or #Argus_InitMode function must be called
185 * first! Otherwise, the function will return an error if it is called
186 * for an yet uninitialized device/handle.
187 *
188 * Also refer to #Argus_Reinit, which re-uses the currently active
189 * measurement mode instead of an user specified measurement mode.
190 *
191 * @note If a full re-initialization is not desired, refer to the
192 * #Argus_RestoreDeviceState function that will only re-write the
193 * register map to the device to restore its state after an power
194 * cycle.
195 *
196 * @param hnd The API handle; contains all internal states and data.
197 *
198 * @param mode The specified measurement mode to be initialized.
199 * Pass 0 as special value to select the current measurement mode
200 * (see #Argus_Init).
201 *
202 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
203 *****************************************************************************/
204status_t Argus_ReinitMode(argus_hnd_t * hnd, argus_mode_t mode);
205
206/*!***************************************************************************
207 * @brief Deinitializes the API modules and the device.
208 *
209 * @details The function deinitializes the device and clear all internal states.
210 * Can be used to cleanup before releasing the memory. The device
211 * can not be used any more and must be initialized again prior to next
212 * usage.
213 *
214 * Note that the #Argus_Init function must be called first! Otherwise,
215 * the function will return an error if it is called for an yet
216 * uninitialized device/handle.
217 *
218 * @param hnd The API handle; contains all internal states and data.
219 *
220 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
221 *****************************************************************************/
222status_t Argus_Deinit(argus_hnd_t * hnd);
223
224/*!***************************************************************************
225 * @brief Creates a new device data handle object to store all internal states.
226 *
227 * @details The function must be called to obtain a new device handle object.
228 * The handle is basically an abstract object in memory that contains
229 * all the internal states and settings of the API module. The handle
230 * is passed to all the API methods in order to address the specified
231 * device. This allows to use the API with more than a single measurement
232 * device.
233 *
234 * The handler is created by calling the memory allocation method from
235 * the standard library: @code void * malloc(size_t size) @endcode
236 * In order to implement an individual memory allocation method,
237 * define and implement the following weakly binded method and return
238 * a pointer to the newly allocated memory. *
239 *
240 * @code void * Argus_Malloc (size_t size) @endcode
241 *
242 * Also see the #Argus_DestroyHandle method for the corresponding
243 * deallocation of the allocated memory.
244 *
245 * @note Although the method is using memory allocated on the heap, it
246 * is eventually no dynamic memory allocation, since the block of
247 * memory is kept all the time and no memory blocks are dynamically
248 * freed and re-allocated. If the usage of heap must be avoided, one
249 * can always implement its own version of the `Argus_Malloc` function
250 * to create the memory elsewhere.
251 *
252 * @return Returns a pointer to the newly allocated device handler object.
253 * Returns a null pointer if the allocation failed!
254 *****************************************************************************/
255argus_hnd_t * Argus_CreateHandle(void);
256
257/*!***************************************************************************
258 * @brief Destroys a given device data handle object.
259 *
260 * @details The function can be called to free the previously created device
261 * data handle object in order to save memory when the device is not
262 * used any more.
263 *
264 * Note that the handle must be deinitialized before it can be
265 * destroyed. The function returns #ERROR_FAIL if the handle is not
266 * yet deinitialized.
267 *
268 * Please refer to the #Argus_CreateHandle method for the corresponding
269 * allocation of the memory.
270 *
271 * The handler is destroyed by freeing the corresponding memory with the
272 * method from the standard library, @code void free(void * ptr) @endcode.
273 * In order to implement an individual memory deallocation method, define
274 * and implement the following weakly binded method and free the memory
275 * object passed to the method by a pointer.
276 *
277 * @code void Argus_Free (void * ptr) @endcode
278 *
279 * Also see the #Argus_CreateHandle method for the corresponding
280 * allocation of the required memory.
281 *
282 * @param hnd The device handle object to be deallocated.
283 *
284 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
285 *****************************************************************************/
286status_t Argus_DestroyHandle(argus_hnd_t * hnd);
287
288/*!***************************************************************************
289 * @brief Restores the device state with a re-write of all register values.
290 *
291 * @details The function invalidates and restores the device state by executing
292 * a re-write of the full register map.
293 *
294 * The purpose of this function is to recover from known external
295 * events like power cycles, for example due to sleep / wake-up
296 * functionality. This can be implemented by cutting off the external
297 * power supply of the device (e.g. via a MOSFET switch controlled by
298 * a GPIB pin). By calling this function, the expected state of the
299 * API is written to the device without the need to fully re-initialize
300 * the device. Thus, the API can resume where it has stopped as if
301 * there has never been a power cycle.
302 *
303 * The internal state machines like the dynamic configuration adaption
304 * (DCA) algorithm will not be reseted. The API/sensor will immediately
305 * resume at the last state that was optimized for the given
306 * environmental conditions.
307 *
308 * The use case of sleep / wake-up can be implemented as follows:
309 *
310 * 1. In case of ongoing measurements, stop the measurements via
311 * the #Argus_StopMeasurementTimer function (if started by the
312 * #Argus_StartMeasurementTimer function).
313 *
314 * 2. Shut down the device by removing the 5V power supply, e.g.
315 * via a GPIO pin that switches a MOSFET circuit.
316 *
317 * 3. After the desired sleep period, power the device by switching
318 * the 5V power supply on again. Wait until the power-on-reset
319 * (POR) is finished (approx. 1 ms) or just repeat step 4 until
320 * it succeeds.
321 *
322 * 4. Call the #Argus_RestoreDeviceState function to trigger the
323 * restoration of the device state in the API. Note that the
324 * function will return an error code if it fails. One can repeat
325 * the execution of that function a few times until it succeeds.
326 *
327 * 6. Continue with measurements via #Argus_StartMeasurementTimer
328 * of #Argus_TriggerMeasurement functions as desired.
329 *
330 * @note If a complete re-initialization (= soft-reset) is desired, see
331 * the #Argus_Reinit functionality.
332 *
333 * @note Changing a configuration or calibration parameter will always
334 * invalidate the device state as well as the state machine of the
335 * dynamic configuration adaption (DCA) algorithm. In that case, the
336 * device/API needs a few measurements to adopt to the present
337 * environmental conditions before the first valid measurement result
338 * can be obtained. This is almost similar to re-initializing the
339 * device (see #Argus_Reinit) which would also re-read the EEPROM.
340 * On the other hand, the #Argus_RestoreDeviceState does not reset
341 * or re-initialize anything. It just makes sure that the device
342 * register map (which has changed to its reset values after the
343 * power cycle) is what the API expects upon the next measurement.
344 *
345 * @param hnd The device handle object to be invalidated.
346 *
347 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
348 *****************************************************************************/
349status_t Argus_RestoreDeviceState(argus_hnd_t * hnd);
350
351/*!**************************************************************************
352 * Generic API
353 ****************************************************************************/
354
355/*!***************************************************************************
356 * @brief Gets the version number of the current API library.
357 *
358 * @details The version is compiled of a major (a), minor (b) and bugfix (c)
359 * number: a.b.c.
360 *
361 * The values are encoded into a 32-bit value:
362 *
363 * - [ 31 .. 24 ] - Major Version Number
364 * - [ 23 .. 16 ] - Minor Version Number
365 * - [ 15 .. 0 ] - Bugfix Version Number
366 * .
367 *
368 * To obtain the parts from the returned uin32_t value:
369 *
370 * @code
371 * uint32_t value = Argus_GetAPIVersion();
372 * uint8_t a = (value >> 24) & 0xFFU;
373 * uint8_t b = (value >> 16) & 0xFFU;
374 * uint8_t c = value & 0xFFFFU;
375 * @endcode
376 *
377 * @return Returns the current version number.
378 *****************************************************************************/
379uint32_t Argus_GetAPIVersion(void);
380
381/*!***************************************************************************
382 * @brief Gets the build number of the current API library.
383 *
384 * @return Returns the current build number as a C-string.
385 *****************************************************************************/
386char const * Argus_GetBuildNumber(void);
387
388/*!***************************************************************************
389 * @brief Gets the version/variant of the module.
390 *
391 * @param hnd The API handle; contains all internal states and data.
392 * @return Returns the current module number.
393 *****************************************************************************/
394argus_module_version_t Argus_GetModuleVersion(argus_hnd_t * hnd);
395
396/*!***************************************************************************
397 * @brief Gets the name string of the module.
398 *
399 * @param hnd The API handle; contains all internal states and data.
400 * @return Returns the current module name.
401 *****************************************************************************/
402char const * Argus_GetModuleName(argus_hnd_t * hnd);
403
404/*!***************************************************************************
405 * @brief Gets the version number of the chip.
406 *
407 * @param hnd The API handle; contains all internal states and data.
408 * @return Returns the current version number.
409 *****************************************************************************/
410argus_chip_version_t Argus_GetChipVersion(argus_hnd_t * hnd);
411
412/*!***************************************************************************
413 * @brief Gets the type number of the device laser.
414 *
415 * @param hnd The API handle; contains all internal states and data.
416 * @return Returns the current device laser type number.
417 *****************************************************************************/
418argus_laser_type_t Argus_GetLaserType(argus_hnd_t * hnd);
419
420/*!***************************************************************************
421 * @brief Gets the unique identification number of the chip.
422 *
423 * @param hnd The API handle; contains all internal states and data.
424 * @return Returns the unique identification number.
425 *****************************************************************************/
426uint32_t Argus_GetChipID(argus_hnd_t * hnd);
427
428/*!***************************************************************************
429 * @brief Gets the SPI hardware slave identifier.
430 *
431 * @param hnd The API handle; contains all internal states and data.
432 * @return The SPI hardware slave identifier.
433 *****************************************************************************/
434s2pi_slave_t Argus_GetSPISlave(argus_hnd_t * hnd);
435
438/*!**************************************************************************
439 * Measurement/Device Operation
440 ****************************************************************************
441 * @addtogroup argus_meas
442 * @{
443 ****************************************************************************/
444
445/*!***************************************************************************
446 * @brief Starts the timer based measurement cycle asynchronously.
447 *
448 * @details This function starts a timer based measurement cycle asynchronously
449 * in the background. A periodic timer interrupt triggers the measurement
450 * frames on the ASIC and the data readout afterwards.
451 *
452 * When the measurement has finished, a callback (which is passed as
453 * a parameter to the function) is invoked in order to inform the
454 * main thread to call the \link #Argus_EvaluateData data evaluation
455 * method\endlink. This call is mandatory to release the data buffer
456 * for the next measurement and it must not be invoked directly from
457 * the callback since it is currently within an interrupt service
458 * routine. Rather a flag should inform the main thread or task
459 * scheduler to invoke the evaluation as soon as possible in order
460 * to not introduce any unwanted delays to the next measurement frame.
461 *
462 * The next measurement frame will be started as soon as the pre-
463 * conditions are meet. These are:
464 * 1. timer flag set (i.e. a certain time has passed since the last
465 * measurement in order to fulfill eye-safety),
466 * 2. device idle (i.e. no measurement currently ongoing) and
467 * 3. data buffer ready (i.e. the previous data has been evaluated).
468 *
469 * Usually, the device idle and data buffer ready conditions are met
470 * before the timer tick occurs and thus the timer dictates the frame
471 * rate.
472 *
473 * The callback function pointer will be invoked when the measurement
474 * frame has finished successfully or whenever an error, that cannot
475 * be handled internally, occurs.
476 *
477 * The periodic timer interrupts are used to check the measurement status
478 * for timeouts. An error is invoked when a measurement cycle have not
479 * finished within the specified time.
480 *
481 * Use #Argus_StopMeasurementTimer to stop the measurements.
482 *
483 * @note In order to use this function, the periodic interrupt timer module
484 * (see @ref argus_timer) must be implemented!
485 *
486 * @param hnd The API handle; contains all internal states and data.
487 *
488 * @param cb Callback function that will be invoked when the measurement
489 * is completed. Its parameters are the \link #status_t status
490 * \endlink of the finished measurement cycle and the pointer to
491 * the calling \link #argus_hnd_t API handle\endlink, i.e. the
492 * /p hnd value. The latter must be passed to the
493 * #Argus_EvaluateData function.
494 * If an error occurred, the status differs from #STATUS_OK.
495 *
496 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
497 *****************************************************************************/
498status_t Argus_StartMeasurementTimer(argus_hnd_t * hnd,
499 argus_measurement_ready_callback_t cb);
500
501/*!***************************************************************************
502 * @brief Stops the timer based measurement cycle.
503 *
504 * @details This function stops the ongoing timer based measurement cycles
505 * that have been started using the #Argus_StartMeasurementTimer
506 * function.
507 *
508 * Note that the function blocks until the current measurements are
509 * finished before returning. This guarantees that the callback was
510 * invoked and the #Argus_EvaluateData function may need to be called
511 * in order to release the data buffer.
512 *
513 * @param hnd The API handle; contains all internal states and data.
514 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
515 *****************************************************************************/
516status_t Argus_StopMeasurementTimer(argus_hnd_t * hnd);
517
518/*!***************************************************************************
519 * @brief Triggers a single measurement frame asynchronously.
520 *
521 * @details This function immediately triggers a single measurement frame
522 * asynchronously if all the pre-conditions are met. Otherwise it
523 * returns with a corresponding status (e.g. #STATUS_BUSY or
524 * #STATUS_ARGUS_POWERLIMIT).
525 *
526 * When the measurement has finished, a callback (which is passed as
527 * a parameter to the function) is invoked in order to inform the
528 * main thread to call the \link #Argus_EvaluateData data evaluation
529 * method\endlink. This call is mandatory to release the data buffer
530 * for the next measurement and it must not be invoked directly from
531 * the callback since it is currently within an interrupt service
532 * routine. Rather a flag should inform the main thread or task
533 * scheduler to invoke the evaluation task.
534 *
535 * The pre-conditions for starting a measurement frame are:
536 * 1. timer flag set (i.e. a certain time has passed since the last
537 * measurement in order to fulfill eye-safety),
538 * 2. device idle (i.e. no measurement currently ongoing) and
539 * 3. data buffer ready (i.e. the previous data has been evaluated).
540 *
541 * The callback function pointer will be invoked when the measurement
542 * frame has finished successfully or whenever an error, that cannot
543 * be handled internally, occurs.
544 *
545 * The successful finishing of the measurement frame is not checked
546 * for timeouts! Instead, the user can call the #Argus_GetStatus()
547 * function on a regular function to do so.
548 *
549 * @note Despite this function triggers a new measurement cycle upon its
550 * invocation, the frame time parameter is still active for this
551 * measurement mode. Basically, the first pre-condition mentioned
552 * above is controlled via the frame time parameter. This means
553 * that measurements cannot be triggered faster than the frame
554 * timer parameters specifies. The maximum integration time (i.e.
555 * exposure time) is also determined by the frame time such that
556 * new measurements are finished with the specified frame time and
557 * the device is ready to trigger a new measurement after the
558 * frame time has elapse.
559 * See #Argus_SetConfigurationFrameTime function for more information
560 * on the frame time.
561 *
562 * @param hnd The API handle; contains all internal states and data.
563 *
564 * @param cb Callback function that will be invoked when the measurement
565 * is completed. Its parameters are the \link #status_t status
566 * \endlink of the finished measurement cycle and the pointer to
567 * the calling \link #argus_hnd_t API handle\endlink, i.e. the
568 * /p hnd value. The latter must be passed to the
569 * #Argus_EvaluateData function.
570 * If an error occurred, the status differs from #STATUS_OK.
571 *
572 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
573 *****************************************************************************/
574status_t Argus_TriggerMeasurement(argus_hnd_t * hnd,
575 argus_measurement_ready_callback_t cb);
576
577
578/*!****************************************************************************
579 * @brief Starts the teach-in measurement mode.
580 *
581 * @details This function starts the teach-in measurement mode which maximizes
582 * the laser output (within the limits of eye-safety) for better
583 * visibility. This can be useful when aligning the sensor to a target
584 * where the laser spot needs to be visible. This is mostly helpful
585 * for the device variants with visible (red) lasers.
586 *
587 * The teach-in measurement mode can (and should) be stopped using the
588 * #Argus_StopTeachInMode function.
589 *
590 * @param hnd The API handle; contains all internal states and data.
591 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
592 *****************************************************************************/
593status_t Argus_StartTeachInMode(argus_hnd_t *hnd);
594
595/*!****************************************************************************
596 * @brief Stops the teach-in measurement mode.
597 *
598 * @details This function stops the teach-in measurement mode which maximizes
599 * the laser output (within the limits of eye-safety) for better
600 * visibility.
601 *
602 * The teach-in measurement mode can be started using the
603 * #Argus_StartTeachInMode function.
604 *
605 * @param hnd The API handle; contains all internal states and data.
606 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
607 *****************************************************************************/
608status_t Argus_StopTeachInMode(argus_hnd_t *hnd);
609
610/*!***************************************************************************
611 * @brief Determines whether a data evaluation is pending.
612 *
613 * @details If the function returns true, a raw buffer is required to be
614 * evaluated to the #Argus_EvaluateData function. The raw data buffer
615 * is filled with raw data from the measurement tasks which need to
616 * be evaluated and the buffer must be freed in order to restart a
617 * new measurement task.
618 *
619 * Note that no configuration parameters can be update until all raw
620 * buffers are evaluated.
621 *
622 * @note See also the #Argus_GetStatus function to obtain the current device
623 * status and error code if any.
624 *
625 * @param hnd The API handle; contains all internal states and data.
626 * @return True if any raw buffer is filled with data that must be evaluated.
627 *****************************************************************************/
628bool Argus_IsDataEvaluationPending(argus_hnd_t * hnd);
629
630/*!***************************************************************************
631 * @brief Determines if the device if active with timer based measurements.
632 * @details If the function returns true, the device is active with timer
633 * scheduled measurements that have been started via the
634 * #Argus_StartMeasurementTimer.
635 *
636 * Note that the active state is independent of the busy state that
637 * is set when the device is actually busy. The active state is also
638 * true if the device is currently idle but waits for the next timer
639 * event to trigger a new measurement cycle.
640 *
641 * @note See also the #Argus_GetStatus function to obtain the current device
642 * status and error code if any.
643 *
644 * @param hnd The API handle; contains all internal states and data.
645 * @return True if the device is operating in timer triggered measurement mode.
646 *****************************************************************************/
647bool Argus_IsTimerMeasurementActive(argus_hnd_t * hnd);
648
649/*!***************************************************************************
650 * @brief Stops the currently ongoing measurements and SPI activity immediately.
651 *
652 * @param hnd The API handle; contains all internal states and data.
653 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
654 *****************************************************************************/
655status_t Argus_Abort(argus_hnd_t * hnd);
656
657/*!***************************************************************************
658 * @brief Checks the state of the device/driver.
659 *
660 * @details Returns the current module status or error if any.
661 *
662 * See the following for a list of errors:
663 *
664 * Status:
665 * - Idle/OK: Device and SPI interface are idle (== #STATUS_IDLE).
666 * - Busy: Device or SPI interface are busy (== #STATUS_BUSY).
667 * - Initializing: The modules and devices are currently initializing
668 * (== #STATUS_INITIALIZING).
669 * .
670 *
671 * Error:
672 * - Not Initialized: The modules (or any submodule) has not been
673 * initialized yet (== #ERROR_NOT_INITIALIZED).
674 * - Not Connected: No device has been connected (or connection errors
675 * have occurred) (== #ERROR_ARGUS_NOT_CONNECTED).
676 * - Timeout: A previous frame measurement has not finished within a
677 * specified time (== #ERROR_TIMEOUT).
678 * .
679 *
680 * @note Note that this function returns the actual busy state. This means
681 * that it will return #STATUS_IDLE during the pause between two
682 * consecutive measurement frames. If the device is active with timer
683 * based measurements (i.e. started via the #Argus_StartMeasurementTimer
684 * function), the return state switches from idle to busy and back
685 * periodically. Use the #Argus_IsTimerMeasurementActive function in
686 * order to determine if the device is active with timer based
687 * measurements.
688 *
689 * @note Note also that the device might reject configuration parameter
690 * update despite the status is #STATUS_IDLE. This is due to the fact
691 * that the internal raw data buffers are still busy and require to
692 * be freed by passing them to the #Argus_EvaluateData function. Use
693 * the #Argus_IsDataEvaluationPending function to see whether any of
694 * the raw data buffers is busy or the configuration can be changed.
695 *
696 * @param hnd The API handle; contains all internal states and data.
697 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
698 *****************************************************************************/
699status_t Argus_GetStatus(argus_hnd_t * hnd);
700
701/*!*****************************************************************************
702 * @brief Tests the connection to the device by sending a ping message.
703 *
704 * @details A ping is transferred to the device in order to check the device and
705 * SPI connection status. Returns #STATUS_OK on success and
706 * #ERROR_ARGUS_NOT_CONNECTED else-wise.
707 *
708 * @param hnd The API handle; contains all internal states and data.
709 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
710 ******************************************************************************/
711status_t Argus_Ping(argus_hnd_t * hnd);
712
713/*!***************************************************************************
714 * @brief Evaluates measurement data from the raw sensor readout data.
715 *
716 * @details This function must be called after each completion of a measurement
717 * cycle. The completion of a measurement cycle is communicated by the
718 * API via the invocation of the measurement data ready callback. The
719 * callback is installed in the API when new measurements are started
720 * either via the #Argus_TriggerMeasurement or via the
721 * #Argus_StartMeasurementTimer functions.
722 *
723 * This function evaluates measurement values like distances, amplitudes
724 * states and auxiliary values like temperature or voltage values from
725 * the raw sensor readout data obtained from the device during the
726 * measurement cycle. A pointer to a #argus_results_t data structure
727 * must be passed where all the evaluated values will be written to.
728 * The structure must persist during the whole execution of the
729 * #Argus_EvaluateData function.
730 *
731 * In addition to the evaluation of measurement data, the function
732 * feeds back the obtained information to the device in order to
733 * optimize its performance with respect to the ambient conditions,
734 * utilizing the so called Dynamic Configuration Adaption (DCA)
735 * feature.
736 *
737 * Furthermore, several calibration algorithm are applied to the data.
738 *
739 * If the function is called without any data ready to be evaluated
740 * from the measurement module, the error code #ERROR_ARGUS_BUFFER_EMPTY
741 * is returned and not data is written to the passed #argus_results_t
742 * data structure.
743 *
744 * @note The call to this function is mandatory for each finished measurement
745 * cycle, i.e. for each call to the measurement data ready callback.
746 * If the function is not called, the data is not evaluated and the
747 * internal raw data buffers are not freed. In that case, they can not
748 * be reused for the next measurement and the API can not start new
749 * measurements.
750 * There are up to two internal buffers available, the to callback
751 * is called twice before the API must wait for the data evaluation
752 * to finish.
753 *
754 * @param hnd The API handle; contains all internal states and data.
755 * @param res A pointer to the results structure that will be populated
756 * with evaluated data.
757 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
758 *****************************************************************************/
759status_t Argus_EvaluateData(argus_hnd_t * hnd, argus_results_t * res);
760
761/*!***************************************************************************
762 * @brief Evaluates measurement data from the raw sensor readout data.
763 *
764 * @details This function enhances the #Argus_EvaluateData by adding additional
765 * debug data into a specified debug data structure (\p dbg). If the
766 * \p dbg is null, the function is eqivalent to the #Argus_EvaluateData
767 * function. This, see #Argus_EvaluateData for reference.
768 *
769 * @param hnd The API handle; contains all internal states and data.
770 * @param res A pointer to the results structure that will be populated
771 * with evaluated data.
772 * @param dbg An optional pointer (can be null) to the debug data structure.
773 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
774 *****************************************************************************/
775status_t Argus_EvaluateDataDebug(argus_hnd_t * hnd, argus_results_t * res,
776 argus_results_debug_t * dbg);
777
778/*!***************************************************************************
779 * @brief Executes a crosstalk calibration measurement.
780 *
781 * @details This function immediately triggers a crosstalk vector calibration
782 * measurement sequence. The ordinary measurement activity is suspended
783 * while the calibration is ongoing.
784 *
785 * In order to perform a crosstalk calibration, the reflection of the
786 * transmitted signal must be kept from the receiver side, by either
787 * covering the TX completely (or RX respectively) or by setting up
788 * an absorbing target at far distance.
789 *
790 * After calibration has finished successfully, the obtained data is
791 * applied immediately and can be read from the API using the
792 * #Argus_GetCalibrationCrosstalkVectorTable function.
793 *
794 * @param hnd The API handle; contains all internal states and data.
795 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
796 *****************************************************************************/
797status_t Argus_ExecuteXtalkCalibrationSequence(argus_hnd_t * hnd);
798
799/*!***************************************************************************
800 * @brief Executes a relative range offset calibration measurement.
801 *
802 * @details This function immediately triggers a relative range offset calibration
803 * measurement sequence. The ordinary measurement activity is suspended
804 * while the calibration is ongoing.
805 *
806 * In order to perform a relative range offset calibration, a flat
807 * calibration target must be setup perpendicular to the sensors
808 * field-of-view.
809 *
810 * \code
811 * AFBR-S50 ToF Sensor
812 * #|
813 * #| |
814 * #|-----+ |
815 * #| RX | |
816 * Reference #|----++ | Calibration
817 * Plane #| TX | | Target
818 * #|----+ |
819 * #| |
820 * #| <------- targetRange -----------------> |
821 * \endcode
822 *
823 * There are two options to run the offset calibration: relative and
824 * absolute.
825 *
826 * - Relative (#Argus_ExecuteRelativeRangeOffsetCalibrationSequence):
827 * when the absolute distance is not essential or the distance to
828 * the calibration target is not known, the relative method can be
829 * used to compensate the relative pixel range offset w.r.t. the
830 * average range. The absolute or global range offset is not changed.
831 * - Absolute (#Argus_ExecuteAbsoluteRangeOffsetCalibrationSequence):
832 * when the absolute distance is essential and the distance to the
833 * calibration target is known, the absolute method can be used to
834 * calibrate the absolute measured distance. Additionally, the
835 * relative pixel offset w.r.t. the average range is also compensated.
836 * .
837 *
838 * After calibration has finished successfully, the obtained data is
839 * applied immediately and can be read from the API using the
840 * #Argus_GetCalibrationPixelRangeOffsets or
841 * #Argus_GetCalibrationGlobalRangeOffsets function.
842 *
843 * @param hnd The API handle; contains all internal states and data.
844 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
845 *****************************************************************************/
846status_t Argus_ExecuteRelativeRangeOffsetCalibrationSequence(argus_hnd_t * hnd);
847
848/*!***************************************************************************
849 * @brief Executes an absolute range offset calibration measurement.
850 *
851 * @details This function immediately triggers an absolute range offset calibration
852 * measurement sequence. The ordinary measurement activity is suspended
853 * while the calibration is ongoing.
854 *
855 * In order to perform a relative range offset calibration, a flat
856 * calibration target must be setup perpendicular to the sensors
857 * field-of-view.
858 *
859 * \code
860 * AFBR-S50 ToF Sensor
861 * #|
862 * #| |
863 * #|-----+ |
864 * #| RX | |
865 * Reference #|----++ | Calibration
866 * Plane #| TX | | Target
867 * #|----+ |
868 * #| |
869 * #| <------- targetRange -----------------> |
870 * \endcode
871 *
872 * There are two options to run the offset calibration: relative and
873 * absolute.
874 *
875 * - Relative (#Argus_ExecuteRelativeRangeOffsetCalibrationSequence):
876 * when the absolute distance is not essential or the distance to
877 * the calibration target is not known, the relative method can be
878 * used to compensate the relative pixel range offset w.r.t. the
879 * average range. The absolute or global range offset is not changed.
880 * - Absolute (#Argus_ExecuteAbsoluteRangeOffsetCalibrationSequence):
881 * when the absolute distance is essential and the distance to the
882 * calibration target is known, the absolute method can be used to
883 * calibrate the absolute measured distance. Additionally, the
884 * relative pixel offset w.r.t. the average range is also compensated.
885 * .
886 *
887 * After calibration has finished successfully, the obtained data is
888 * applied immediately and can be read from the API using the
889 * #Argus_GetCalibrationPixelRangeOffsets or
890 * #Argus_GetCalibrationGlobalRangeOffsets function.
891 *
892 * @param hnd The API handle; contains all internal states and data.
893 * @param targetRange The absolute range between the reference plane and the
894 * calibration target in meter an Q9.22 format.
895 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
896 *****************************************************************************/
897status_t Argus_ExecuteAbsoluteRangeOffsetCalibrationSequence(argus_hnd_t * hnd,
898 q9_22_t targetRange);
899
902/*!**************************************************************************
903 * Configuration API
904 ****************************************************************************
905 * @addtogroup argus_cfg
906 * @{
907 ****************************************************************************/
908
909/*!***************************************************************************
910 * @brief Gets the default measurement mode for a specified module type.
911 *
912 * @param module The specified module type.
913 * @return Returns the default measurement mode for the specified module type.
914 *****************************************************************************/
915argus_mode_t Argus_GetDefaultMeasurementMode(argus_module_version_t module);
916
917/*!***************************************************************************
918 * @brief Sets the measurement mode to a specified device.
919 *
920 * @details This generates a new default configuration and calibration for the
921 * specified measurement mode and applies it to the device.
922 *
923 * See #argus_mode_t for a list of all available measurement modes.
924 *
925 * @warning The function overwrites all made changes to the configuration or
926 * calibration parameters with the default values. So this function
927 * must be called before any other changes to the configuration or
928 * calibration parameters are made!
929 *
930 * @param hnd The API handle; contains all internal states and data.
931 * @param mode The new measurement mode.
932 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
933 *****************************************************************************/
934status_t Argus_SetMeasurementMode(argus_hnd_t * hnd, argus_mode_t mode);
935
936/*!***************************************************************************
937 * @brief Resets the measurement mode to a specified device.
938 *
939 * @details This generates a new default configuration and calibration for the
940 * current measurement mode and applies it to the device.
941 *
942 * @warning The function overwrites all made changes to the configuration or
943 * calibration parameters with the default values. So this function
944 * must be called before any other changes to the configuration or
945 * calibration parameters are made!
946 *
947 * @param hnd The API handle; contains all internal states and data.
948 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
949 *****************************************************************************/
950status_t Argus_ResetMeasurementMode(argus_hnd_t * hnd);
951
952/*!***************************************************************************
953 * @brief Gets the measurement mode from a specified device.
954 *
955 * @param hnd The API handle; contains all internal states and data.
956 * @param mode The current measurement mode.
957 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
958 *****************************************************************************/
959status_t Argus_GetMeasurementMode(argus_hnd_t * hnd, argus_mode_t * mode);
960
961/*!***************************************************************************
962 * @brief Sets the frame time to a specified device.
963 *
964 * @details The frame time determines the measurement rate of the device.
965 * Usually, this controller the periodicity of measurements to be
966 * triggered via the timer based measurement mode that can be started
967 * via the #Argus_StartMeasurementTimer function. But also the
968 * behavior of the #Argus_TriggerMeasurement function is influenced
969 * by the frame rate parameter.
970 *
971 * The frame time parameter handles the maximum frame rate by limiting
972 * the trigger of a new measurement frame to the specified value.
973 * On the other hand, the accuracy of measurement results it also
974 * influenced since the frame time specifies the maximum integration
975 * depth (i.e. exposure time) along with the laser safety limitations.
976 * This means, the measurement speed can be increased by decreasing
977 * the frame time parameter and the accuracy can be improved by
978 * increasing the frame time parameter.
979 *
980 * Note the additional factor will limit the maximum frame rate on the
981 * one hand and the accuracy on the other hand:
982 * - High CPU load (or slow CPU in general) will lead to delays due
983 * to long data evaluation task (#Argus_EvaluateData) or long user
984 * application code. Reduce CPU load or increase CPU power to
985 * increase maximum frame rate.
986 * - The dual frequency mode (DFM, see #Argus_SetConfigurationDFMMode)
987 * will additionally limit the maximum frame rate to approximately
988 * 100 frames per second. Disable the DFM to increase maximum frame
989 * rates.
990 * - The smart power save (SPS, see
991 * #Argus_SetConfigurationSmartPowerSaveEnabled) mode will decrease
992 * the maximum possible frame rate slightly. Disable it to increase
993 * the maximum frame rate.
994 * - The dynamic configuration adaption with its specific power saving
995 * ratio parameter (see #Argus_SetConfigurationDynamicAdaption)
996 * will limit the maximum integration depth along with the laser
997 * safety limitations. Increase the power saving ratio to increase
998 * accuracy. Note that laser safety limitations might already limit
999 * the maximum integration depth such that the power saving ratio
1000 * is ineffective.
1001 * .
1002 *
1003 * @param hnd The API handle; contains all internal states and data.
1004 * @param value The measurement frame time in microseconds.
1005 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1006 *****************************************************************************/
1007status_t Argus_SetConfigurationFrameTime(argus_hnd_t * hnd, uint32_t value);
1008
1009/*!***************************************************************************
1010 * @brief Gets the frame time from a specified device.
1011 *
1012 * @param hnd The API handle; contains all internal states and data.
1013 * @param value The current frame time in microseconds.
1014 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1015 *****************************************************************************/
1016status_t Argus_GetConfigurationFrameTime(argus_hnd_t * hnd, uint32_t * value);
1017
1018/*!***************************************************************************
1019 * @brief Sets the smart power save enabled flag to a specified device.
1020 *
1021 * @param hnd The API handle; contains all internal states and data.
1022 * @param value The new smart power save enabled flag.
1023 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1024 *****************************************************************************/
1025status_t Argus_SetConfigurationSmartPowerSaveEnabled(argus_hnd_t * hnd,
1026 bool value);
1027
1028/*!***************************************************************************
1029 * @brief Gets the smart power save enabled flag from a specified device.
1030 *
1031 * @param hnd The API handle; contains all internal states and data.
1032 * @param value The current smart power save enabled flag.
1033 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1034 *****************************************************************************/
1035status_t Argus_GetConfigurationSmartPowerSaveEnabled(argus_hnd_t * hnd,
1036 bool * value);
1037
1038/*!***************************************************************************
1039 * @brief Sets the Dual Frequency Mode (DFM) to a specified device.
1040 *
1041 * @param hnd The API handle; contains all internal states and data.
1042 * @param value The new DFM mode value.
1043 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1044 *****************************************************************************/
1045status_t Argus_SetConfigurationDFMMode(argus_hnd_t * hnd,
1046 argus_dfm_mode_t value);
1047
1048
1049/*!***************************************************************************
1050 * @brief Gets the Dual Frequency Mode (DFM) from a specified device.
1051 *
1052 * @param hnd The API handle; contains all internal states and data.
1053 * @param value The current DFM mode value.
1054 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1055 *****************************************************************************/
1056status_t Argus_GetConfigurationDFMMode(argus_hnd_t * hnd,
1057 argus_dfm_mode_t * value);
1058
1059/*!***************************************************************************
1060 * @brief Sets the Shot Noise Monitor (SNM) mode to a specified device.
1061 *
1062 * @param hnd The API handle; contains all internal states and data.
1063 * @param value The new SNM mode value.
1064 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1065 *****************************************************************************/
1066status_t Argus_SetConfigurationShotNoiseMonitorMode(argus_hnd_t * hnd,
1067 argus_snm_mode_t value);
1068
1069/*!***************************************************************************
1070 * @brief Gets the Shot Noise Monitor (SNM) mode from a specified device.
1071 *
1072 * @param hnd The API handle; contains all internal states and data.
1073 * @param value The current SNM mode value.
1074 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1075 *****************************************************************************/
1076status_t Argus_GetConfigurationShotNoiseMonitorMode(argus_hnd_t * hnd,
1077 argus_snm_mode_t * value);
1078
1079/*!***************************************************************************
1080* @brief Sets the Crosstalk Monitor (XTM) mode to a specified device.
1081*
1082* @see Argus_SetConfigurationCrosstalkMonitor for the full configuration
1083* of the crosstalk monitor.
1084*
1085* @param hnd The API handle; contains all internal states and data.
1086* @param value The new XTM mode value (true: enabled; false: disabled).
1087* @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1088*****************************************************************************/
1089status_t Argus_SetConfigurationCrosstalkMonitorMode(argus_hnd_t * hnd,
1090 bool value);
1091
1092/*!***************************************************************************
1093* @brief Gets the Crosstalk Monitor (XTM) mode from a specified device.
1094*
1095* @see Argus_GetConfigurationCrosstalkMonitor for the full configuration
1096* of the crosstalk monitor.
1097*
1098* @param hnd The API handle; contains all internal states and data.
1099* @param value The current XTM mode value (true: enabled; false: disabled).
1100* @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1101*****************************************************************************/
1102status_t Argus_GetConfigurationCrosstalkMonitorMode(argus_hnd_t * hnd,
1103 bool * value);
1104
1105/*!***************************************************************************
1106 * @brief Sets the full DCA module configuration to a specified device.
1107 *
1108 * @param hnd The API handle; contains all internal states and data.
1109 * @param value The new DCA configuration set.
1110 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1111 *****************************************************************************/
1112status_t Argus_SetConfigurationDynamicAdaption(argus_hnd_t * hnd,
1113 argus_cfg_dca_t const * value);
1114
1115/*!***************************************************************************
1116 * @brief Gets the # from a specified device.
1117 *
1118 * @param hnd The API handle; contains all internal states and data.
1119 * @param value The current DCA configuration set value.
1120 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1121 *****************************************************************************/
1122status_t Argus_GetConfigurationDynamicAdaption(argus_hnd_t * hnd,
1123 argus_cfg_dca_t * value);
1124
1125/*!***************************************************************************
1126 * @brief Sets the Noise Detectors feature configuration to a specified device.
1127 *
1128 * @param hnd The API handle; contains all internal states and data.
1129 * @param value The new ND configuration set.
1130 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1131 *****************************************************************************/
1132status_t Argus_SetConfigurationNoiseDetectors(argus_hnd_t * hnd,
1133 argus_cfg_nd_t const * value);
1134
1135/*!***************************************************************************
1136 * @brief Gets the Noise Detectors feature configuration from a specified device.
1137 *
1138 * @param hnd The API handle; contains all internal states and data.
1139 * @param value The current ND configuration set value.
1140 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1141 *****************************************************************************/
1142status_t Argus_GetConfigurationNoiseDetectors(argus_hnd_t * hnd,
1143 argus_cfg_nd_t * value);
1144
1145/*!***************************************************************************
1146 * @brief Sets the pixel binning configuration parameters to a specified device.
1147 *
1148 * @param hnd The API handle; contains all internal states and data.
1149 * @param value The new pixel binning configuration parameters.
1150 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1151 *****************************************************************************/
1152status_t Argus_SetConfigurationPixelBinning(argus_hnd_t * hnd,
1153 argus_cfg_pba_t const * value);
1154
1155/*!***************************************************************************
1156 * @brief Gets the pixel binning configuration parameters from a specified device.
1157 *
1158 * @param hnd The API handle; contains all internal states and data.
1159 * @param value The current pixel binning configuration parameters.
1160 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1161 *****************************************************************************/
1162status_t Argus_GetConfigurationPixelBinning(argus_hnd_t * hnd,
1163 argus_cfg_pba_t * value);
1164
1165/*!***************************************************************************
1166 * @brief Sets the crosstalk monitor (XTM) configuration parameters to a specified device.
1167 *
1168 * @see Argus_SetConfigurationCrosstalkMonitorMode for the simpler version
1169 * of the function to only change the crosstalk monitor mode.
1170 *
1171 * @param hnd The API handle; contains all internal states and data.
1172 * @param value The new crosstalk monitor configuration parameters.
1173 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1174 *****************************************************************************/
1175status_t Argus_SetConfigurationCrosstalkMonitor(argus_hnd_t * hnd,
1176 argus_cfg_xtm_t const * value);
1177
1178/*!***************************************************************************
1179 * @brief Gets the crosstalk monitor (XTM) configuration parameters from a specified device.
1180 *
1181 * @see Argus_GetConfigurationCrosstalkMonitorMode for the simpler version
1182 * of the function to only change the crosstalk monitor mode.
1183 *
1184 * @param hnd The API handle; contains all internal states and data.
1185 * @param value The current crosstalk monitor configuration parameters.
1186 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1187 *****************************************************************************/
1188status_t Argus_GetConfigurationCrosstalkMonitor(argus_hnd_t * hnd,
1189 argus_cfg_xtm_t * value);
1190
1191/*!***************************************************************************
1192 * @brief Gets the current unambiguous range in mm.
1193 *
1194 * @param hnd The API handle; contains all internal states and data.
1195 * @param range_mm The returned range in mm.
1196 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1197 *****************************************************************************/
1198status_t Argus_GetConfigurationUnambiguousRange(argus_hnd_t * hnd,
1199 uint32_t * range_mm);
1200
1203/*!**************************************************************************
1204 * Calibration API
1205 ****************************************************************************
1206 * @addtogroup argus_cal
1207 * @{
1208 ****************************************************************************/
1209
1210/*!***************************************************************************
1211 * @brief Sets the global range offset values to a specified device.
1212 *
1213 * @details The global range offsets are subtracted from the raw range values.
1214 * There are two distinct values that are applied in low or high
1215 * power stage setting respectively.
1216 *
1217 * @param hnd The API handle; contains all internal states and data.
1218 * @param offset_low The new global range offset for the low power stage in
1219 * meter and Q0.15 format.
1220 * @param offset_high The new global range offset for the high power stage in
1221 * meter and Q0.15 format.
1222 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1223 *****************************************************************************/
1224status_t Argus_SetCalibrationGlobalRangeOffsets(argus_hnd_t * hnd,
1225 q0_15_t offset_low,
1226 q0_15_t offset_high);
1227
1228/*!***************************************************************************
1229 * @brief Gets the global range offset values from a specified device.
1230 *
1231 * @details The global range offsets are subtracted from the raw range values.
1232 * There are two distinct values that are applied in low or high
1233 * power stage setting respectively.
1234 *
1235 * @param hnd The API handle; contains all internal states and data.
1236 * @param offset_low The current range offset for the low power stage in
1237 * meter and Q0.15 format.
1238 * @param offset_high The current global range offset for the high power stage
1239 * in meter and Q0.15 format.
1240 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1241 *****************************************************************************/
1242status_t Argus_GetCalibrationGlobalRangeOffsets(argus_hnd_t * hnd,
1243 q0_15_t * offset_low,
1244 q0_15_t * offset_high);
1245
1246/*!***************************************************************************
1247 * @brief Sets the relative pixel offset table to a specified device.
1248 *
1249 * @details The relative pixel offset values are subtracted from the raw range
1250 * values for each individual pixel. Note that a global range offset
1251 * is applied additionally. The relative pixel offset values are meant
1252 * to be with respect to the average range of all pixels, i.e. the
1253 * average of all relative offsets should be 0!
1254 *
1255 * The crosstalk vector table is a two dimensional array of type
1256 * #q0_15_t, wrapped within the #argus_cal_offset_table_t structure.
1257 *
1258 * The dimensions are:
1259 * - size(0) = #ARGUS_PIXELS_X (Pixel count in x-direction)
1260 * - size(1) = #ARGUS_PIXELS_Y (Pixel count in y-direction)
1261 * .
1262 *
1263 * Its recommended to use the built-in pixel offset calibration
1264 * sequence (see #Argus_ExecuteRelativeRangeOffsetCalibrationSequence)
1265 * to determine the offset table for the current device.
1266 *
1267 * If a constant offset table for all device needs to be incorporated
1268 * into the sources, the #Argus_GetPixelRangeOffsets_Callback
1269 * should be used.
1270 *
1271 * @param hnd The API handle; contains all internal states and data.
1272 * @param value The new relative range offset in meter and Q0.15 format.
1273 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1274 *****************************************************************************/
1275status_t Argus_SetCalibrationPixelRangeOffsets(argus_hnd_t * hnd,
1276 argus_cal_offset_table_t const * value);
1277
1278
1279/*!***************************************************************************
1280 * @brief Gets the relative pixel offset table from a specified device.
1281 *
1282 * @details The relative pixel offset values are subtracted from the raw range
1283 * values for each individual pixel. Note that a global range offset
1284 * is applied additionally. The relative pixel offset values are meant
1285 * to be with respect to the average range of all pixels, i.e. the
1286 * average of all relative offsets should be 0!
1287 *
1288 * The crosstalk vector table is a two dimensional array of type
1289 * #q0_15_t, wrapped within the #argus_cal_offset_table_t structure.
1290 *
1291 * The dimensions are:
1292 * - size(0) = #ARGUS_PIXELS_X (Pixel count in x-direction)
1293 * - size(1) = #ARGUS_PIXELS_Y (Pixel count in y-direction)
1294 * .
1295 *
1296 * @param hnd The API handle; contains all internal states and data.
1297 * @param value The current relative range offset in meter and Q0.15 format.
1298 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1299 *****************************************************************************/
1300status_t Argus_GetCalibrationPixelRangeOffsets(argus_hnd_t * hnd,
1301 argus_cal_offset_table_t * value);
1302
1303
1304/*!***************************************************************************
1305 * @brief Resets the relative pixel offset values for the specified device to
1306 * the factory calibrated default values.
1307 *
1308 * @details The relative pixel offset values are subtracted from the raw range
1309 * values for each individual pixel. Note that a global range offset
1310 * is applied additionally.
1311 *
1312 * The factory defaults are device specific values.
1313 *
1314 * @param hnd The API handle; contains all internal states and data.
1315 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1316 *****************************************************************************/
1317status_t Argus_ResetCalibrationPixelRangeOffsets(argus_hnd_t * hnd);
1318
1319/*!***************************************************************************
1320 * @brief A callback that returns the external pixel range offsets.
1321 *
1322 * @details The function needs to be implemented by the host application in
1323 * order to set the external pixel range offsets values upon system
1324 * initialization. If not defined in user code, the default
1325 * implementation will return an all zero offset table, assuming there
1326 * is no (additional) external pixel range offset values.
1327 *
1328 * If defined in user code, the function must fill all offset values
1329 * in the provided \par offsets parameter with external range offset
1330 * values.
1331 * The values can be obtained by the calibration routine.
1332 *
1333 * Example usage:
1334 *
1335 * @code
1336 * status_t Argus_GetPixelRangeOffsets_Callback(argus_cal_offset_table_t offsets)
1337 * {
1338 * memset(offsets, 0, sizeof(argus_cal_offset_t));
1339 *
1340 * // Set offset values in meter and Q0.15 format.
1341 * offsets.Table[0][0] = -3542;
1342 * offsets.Table[0][1] = -4385;
1343 * offsets.Table[0][2] = 2953;
1344 * // etc.
1345 * }
1346 * @endcode
1347 *
1348 * @param offsets The pixel range offsets in meter and Q0.15 format; to be
1349 * filled with data.
1350 * @param mode The current measurement mode.
1351 *****************************************************************************/
1352void Argus_GetPixelRangeOffsets_Callback(argus_cal_offset_table_t * offsets,
1353 argus_mode_t const mode);
1354
1355/*!***************************************************************************
1356 * @brief Sets the sample time for the range offset calibration sequence.
1357 *
1358 * @details Gets the measurement sample acquisition time for executing the
1359 * range offset calibration sequence and generate the offset data.\n
1360 * Units: msec.
1361 *
1362 * @note Since the range offset calibration is executed twice (once for
1363 * low and once for high laser power stages), the actual calibration
1364 * time will be twice as long as set by the sample time parameter.
1365 *
1366 * @param hnd The API handle; contains all internal states and data.
1367 * @param value The new range offset calibration sequence sample time.
1368 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1369 *****************************************************************************/
1370status_t Argus_SetCalibrationRangeOffsetSequenceSampleTime(argus_hnd_t * hnd, uint16_t value);
1371
1372/*!***************************************************************************
1373 * @brief Gets the sample time for the range offset calibration sequence.
1374 *
1375 * @details Gets the measurement sample acquisition time for executing the
1376 * range offset calibration sequence and generate the offset data.\n
1377 * Units: msec.
1378 *
1379 * @note Since the range offset calibration is executed twice (once for
1380 * low and once for high laser power stages), the actual calibration
1381 * time will be twice as long as set by the sample time parameter.
1382 *
1383 * @param hnd The API handle; contains all internal states and data.
1384 * @param value The current range offset calibration sequence sample time.
1385 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1386 *****************************************************************************/
1387status_t Argus_GetCalibrationRangeOffsetSequenceSampleTime(argus_hnd_t * hnd, uint16_t * value);
1388
1389/*!***************************************************************************
1390 * @brief Sets the pixel-to-pixel crosstalk compensation parameters to a specified device.
1391 *
1392 * @param hnd The API handle; contains all internal states and data.
1393 * @param value The new pixel-to-pixel crosstalk compensation parameters.
1394 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1395 *****************************************************************************/
1396status_t Argus_SetCalibrationCrosstalkPixel2Pixel(argus_hnd_t * hnd,
1397 argus_cal_p2pxtalk_t const * value);
1398
1399/*!***************************************************************************
1400 * @brief Gets the pixel-to-pixel crosstalk compensation parameters from a specified device.
1401 *
1402 * @param hnd The API handle; contains all internal states and data.
1403 * @param value The current pixel-to-pixel crosstalk compensation parameters.
1404 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1405 *****************************************************************************/
1406status_t Argus_GetCalibrationCrosstalkPixel2Pixel(argus_hnd_t * hnd,
1407 argus_cal_p2pxtalk_t * value);
1408
1409
1410/*!***************************************************************************
1411 * @brief Sets the custom crosstalk vector table to a specified device.
1412 *
1413 * @details The crosstalk vectors are subtracted from the raw sampling data
1414 * in the data evaluation phase.
1415 *
1416 * The crosstalk vector table is a three dimensional array of type
1417 * #xtalk_t. The #argus_cal_xtalk_table_t is the corresponding
1418 * typedef for the required data.
1419 *
1420 * The dimensions are:
1421 * - size(0) = #ARGUS_DFM_FRAME_COUNT (Dual-frequency mode A- or B-frame)
1422 * - size(1) = #ARGUS_PIXELS_X (Pixel count in x-direction)
1423 * - size(2) = #ARGUS_PIXELS_Y (Pixel count in y-direction)
1424 * .
1425 *
1426 * Its recommended to use the built-in crosstalk calibration sequence
1427 * (see #Argus_ExecuteXtalkCalibrationSequence) to determine the
1428 * crosstalk vector table.
1429 *
1430 * If a constant table for all device needs to be incorporated into
1431 * the sources, the #Argus_GetCrosstalkVectorTable_Callback
1432 * should be used.
1433 *
1434 * @param hnd The API handle; contains all internal states and data.
1435 * @param value The new crosstalk vector table.
1436 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1437 *****************************************************************************/
1438status_t Argus_SetCalibrationCrosstalkVectorTable(argus_hnd_t * hnd,
1439 argus_cal_xtalk_table_t const * value);
1440
1441/*!***************************************************************************
1442 * @brief Gets the custom crosstalk vector table from a specified device.
1443 *
1444 * @details The crosstalk vectors are subtracted from the raw sampling data
1445 * in the data evaluation phase.
1446 *
1447 * The crosstalk vector table is a three dimensional array of type
1448 * #xtalk_t. The #argus_cal_xtalk_table_t is the corresponding
1449 * typedef for the required data.
1450 *
1451 * The dimensions are:
1452 * - size(0) = #ARGUS_DFM_FRAME_COUNT (Dual-frequency mode A- or B-frame)
1453 * - size(1) = #ARGUS_PIXELS_X (Pixel count in x-direction)
1454 * - size(2) = #ARGUS_PIXELS_Y (Pixel count in y-direction)
1455 * .
1456 *
1457 * @param hnd The API handle; contains all internal states and data.
1458 * @param value The current crosstalk vector table.
1459 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1460 *****************************************************************************/
1461status_t Argus_GetCalibrationCrosstalkVectorTable(argus_hnd_t * hnd,
1462 argus_cal_xtalk_table_t * value);
1463
1464/*!***************************************************************************
1465 * @brief Resets the crosstalk vector table for the specified device to the
1466 * factory calibrated default values.
1467 *
1468 * @details The crosstalk vectors are subtracted from the raw sampling data
1469 * in the data evaluation phase.
1470 * *
1471 * The factory defaults are device specific calibrated values.
1472 *
1473 * @param hnd The API handle; contains all internal states and data.
1474 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1475 *****************************************************************************/
1476status_t Argus_ResetCalibrationCrosstalkVectorTable(argus_hnd_t * hnd);
1477
1478/*!***************************************************************************
1479 * @brief Sets the sample time for the crosstalk calibration sequence.
1480 *
1481 * @details Sets the measurement sample acquisition time for executing the
1482 * crosstalk calibration sequence and generate the crosstalk data.\n
1483 * Units: msec.
1484 *
1485 * @param hnd The API handle; contains all internal states and data.
1486 * @param value The new crosstalk calibration sequence sample time.
1487 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1488 *****************************************************************************/
1489status_t Argus_SetCalibrationCrosstalkSequenceSampleTime(argus_hnd_t * hnd,
1490 uint16_t value);
1491
1492/*!***************************************************************************
1493 * @brief Gets the sample time for the crosstalk calibration sequence.
1494 *
1495 * @details Gets the measurement sample acquisition time for executing the
1496 * crosstalk calibration sequence and generate the crosstalk data.\n
1497 * Units: msec.
1498 *
1499 * @param hnd The API handle; contains all internal states and data.
1500 * @param value The current crosstalk calibration sequence sample time.
1501 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1502 *****************************************************************************/
1503status_t Argus_GetCalibrationCrosstalkSequenceSampleTime(argus_hnd_t * hnd,
1504 uint16_t * value);
1505
1506/*!***************************************************************************
1507 * @brief Sets the max. amplitude threshold for the crosstalk calibration sequence.
1508 *
1509 * @details The maximum amplitude threshold defines a maximum crosstalk vector
1510 * amplitude before causing an error message. If the crosstalk is
1511 * too high, there is usually an issue with the measurement setup, i.e.
1512 * there is still a measurement signal detected.
1513 *
1514 * @param hnd The API handle; contains all internal states and data.
1515 * @param value The new crosstalk calibration sequence maximum amplitude
1516 * threshold value in UQ12.4 format.
1517 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1518 *****************************************************************************/
1519status_t Argus_SetCalibrationCrosstalkSequenceAmplitudeThreshold(argus_hnd_t * hnd,
1520 uq12_4_t value);
1521
1522/*!***************************************************************************
1523 * @brief Gets the max. amplitude threshold for the crosstalk calibration sequence.
1524 *
1525 * @details The maximum amplitude threshold defines a maximum crosstalk vector
1526 * amplitude before causing an error message. If the crosstalk is
1527 * too high, there is usually an issue with the measurement setup, i.e.
1528 * there is still a measurement signal detected.
1529 *
1530 * @param hnd The API handle; contains all internal states and data.
1531 * @param value The current max. amplitude threshold value in UQ12.4 format.
1532 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1533 *****************************************************************************/
1534status_t Argus_GetCalibrationCrosstalkSequenceAmplitudeThreshold(argus_hnd_t * hnd,
1535 uq12_4_t * value);
1536
1537
1538/*!***************************************************************************
1539 * @brief Clears all user calibration values from NVM for the specified device.
1540 *
1541 * @details The user calibration values are stored in the non-volatile memory
1542 * (NVM) if corresponding \link #argus_nvm NVM hardware layer\endlink
1543 * is implemented. This method clears the user calibration data from
1544 * the non-volatile memory.
1545 *
1546 * @warning This does not reset the currently set calibration values to
1547 * factory defaults!
1548 *
1549 * @param hnd The API handle; contains all internal states and data.
1550 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1551 *****************************************************************************/
1552status_t Argus_ClearUserCalibration(argus_hnd_t * hnd);
1553
1554
1555/*!***************************************************************************
1556 * @brief A callback that returns the external crosstalk vector table.
1557 *
1558 * @details The function needs to be implemented by the host application in
1559 * order to set the external crosstalk vector table upon system
1560 * initialization. If not defined in user code, the default
1561 * implementation will return an all zero vector table, assuming there
1562 * is no (additional) external crosstalk.
1563 *
1564 * If defined in user code, the function must fill all vector values
1565 * in the provided \par crosstalk parameter with external crosstalk
1566 * values. The values can be obtained by the calibration routine.
1567 *
1568 * Example usage:
1569 *
1570 * @code
1571 * status_t Argus_GetCrosstalkVectorTable_Callback(
1572 * argus_cal_xtalk_table_t * xtalk)
1573 * {
1574 * memset(xtalk, 0, sizeof(argus_cal_xtalk_table_t));
1575 *
1576 * // Set crosstalk vectors in Q11.4 format.
1577 * // Note on dual-frequency frame index: 0 = A-Frame; 1 = B-Frame
1578 * xtalk.FrameA[0][0].dS = -9; xtalk.FrameB[0][0].dC = -11;
1579 * xtalk.FrameA[0][1].dS = -13; xtalk.FrameB[0][1].dC = -16;
1580 * xtalk.FrameA[0][2].dS = 6; xtalk.FrameB[0][2].dC = -18;
1581 * // etc.
1582 * }
1583 * @endcode
1584 *
1585 * @param xtalk The crosstalk vector array; to be filled with data.
1586 * @param mode The current measurement mode.
1587 *****************************************************************************/
1588void Argus_GetCrosstalkVectorTable_Callback(argus_cal_xtalk_table_t * xtalk,
1589 argus_mode_t const mode);
1590
1591
1592/*!***************************************************************************
1593 * @brief Gets the currently calibrated Golden Pixel coordinates.
1594 *
1595 * @details The Golden Pixel is the pixel that is located at the center of the
1596 * receiving light beam. Thus it it the one that receives the most
1597 * signal and plays a central role in 1D measurement systems.
1598 *
1599 * The function fills the provided \p x and \p y parameters with
1600 * the Golden Pixel coordinates. Typical values are x = 5 and y = 1
1601 * or 2. But the actual values depend on the specific sensor.
1602 *
1603 * Please also note the utility functions provided in the \ref argus_map
1604 * module to convert between pixel coordinates and channel numbers or
1605 * shift pixel maps by a position offset (#ShiftSelectedPixels) or
1606 * generate pixel masks centered around the Golden Pixel
1607 * (#FillPixelMask).
1608 *
1609 * @param hnd The API handle; contains all internal states and data.
1610 * @param x The Golden Pixel x-coordinate.
1611 * @param y The Golden Pixel y-coordinate.
1612 * @return Returns the \link #status_t status\endlink (#STATUS_OK on success).
1613 *****************************************************************************/
1614status_t Argus_GetCalibrationGoldenPixel(argus_hnd_t const * hnd, uint8_t * x, uint8_t * y);
1615
1617#ifdef __cplusplus
1618} // extern "C"
1619#endif
1620#endif /* ARGUS_API_H */
argus_def.h
This file is part of the AFBR-S50 hardware API.
argus_dfm.h
This file is part of the AFBR-S50 API.
argus_nd.h
This file is part of the AFBR-S50 API.
argus_offset.h
This file is part of the AFBR-S50 hardware API.
argus_pba.h
This file is part of the AFBR-S50 API.
argus_res.h
This file is part of the AFBR-S50 API.
argus_snm.h
This file is part of the AFBR-S50 API.
argus_xtalk.h
This file is part of the AFBR-S50 hardware API.
Argus_GetLaserType
argus_laser_type_t Argus_GetLaserType(argus_hnd_t *hnd)
Gets the type number of the device laser.
Argus_DestroyHandle
status_t Argus_DestroyHandle(argus_hnd_t *hnd)
Destroys a given device data handle object.
Argus_GetSPISlave
s2pi_slave_t Argus_GetSPISlave(argus_hnd_t *hnd)
Gets the SPI hardware slave identifier.
Argus_GetModuleVersion
argus_module_version_t Argus_GetModuleVersion(argus_hnd_t *hnd)
Gets the version/variant of the module.
argus_module_version_t
argus_module_version_t
The AFBR-S50 module types.
Definition argus_def.h:93
Argus_RestoreDeviceState
status_t Argus_RestoreDeviceState(argus_hnd_t *hnd)
Restores the device state with a re-write of all register values.
argus_measurement_ready_callback_t
status_t(* argus_measurement_ready_callback_t)(status_t status, argus_hnd_t *hnd)
Measurement Ready API callback function.
Definition argus_def.h:351
Argus_GetChipVersion
argus_chip_version_t Argus_GetChipVersion(argus_hnd_t *hnd)
Gets the version number of the chip.
Argus_GetModuleName
char const * Argus_GetModuleName(argus_hnd_t *hnd)
Gets the name string of the module.
Argus_InitMode
status_t Argus_InitMode(argus_hnd_t *hnd, s2pi_slave_t spi_slave, argus_mode_t mode)
Initializes the device with specified measurement mode.
Argus_Init
status_t Argus_Init(argus_hnd_t *hnd, s2pi_slave_t spi_slave)
Initializes the device with default measurement mode.
Argus_GetChipID
uint32_t Argus_GetChipID(argus_hnd_t *hnd)
Gets the unique identification number of the chip.
Argus_ReinitMode
status_t Argus_ReinitMode(argus_hnd_t *hnd, argus_mode_t mode)
Reinitializes the device with a specified measurement mode.
Argus_CreateHandle
argus_hnd_t * Argus_CreateHandle(void)
Creates a new device data handle object to store all internal states.
argus_hnd_t
struct argus_hnd_t argus_hnd_t
Definition argus_def.h:320
argus_chip_version_t
argus_chip_version_t
The AFBR-S50 chip versions.
Definition argus_def.h:200
s2pi_slave_t
int32_t s2pi_slave_t
Definition argus_api.h:68
Argus_Reinit
status_t Argus_Reinit(argus_hnd_t *hnd)
Reinitializes the device with the current measurement mode.
argus_mode_t
argus_mode_t
The measurement modes.
Definition argus_def.h:276
Argus_GetAPIVersion
uint32_t Argus_GetAPIVersion(void)
Gets the version number of the current API library.
Argus_GetBuildNumber
char const * Argus_GetBuildNumber(void)
Gets the build number of the current API library.
Argus_Deinit
status_t Argus_Deinit(argus_hnd_t *hnd)
Deinitializes the API modules and the device.
argus_laser_type_t
argus_laser_type_t
The AFBR-S50 laser configurations.
Definition argus_def.h:175
Argus_SetCalibrationCrosstalkVectorTable
status_t Argus_SetCalibrationCrosstalkVectorTable(argus_hnd_t *hnd, argus_cal_xtalk_table_t const *value)
Sets the custom crosstalk vector table to a specified device.
Argus_ClearUserCalibration
status_t Argus_ClearUserCalibration(argus_hnd_t *hnd)
Clears all user calibration values from NVM for the specified device.
Argus_GetCalibrationPixelRangeOffsets
status_t Argus_GetCalibrationPixelRangeOffsets(argus_hnd_t *hnd, argus_cal_offset_table_t *value)
Gets the relative pixel offset table from a specified device.
Argus_ResetCalibrationPixelRangeOffsets
status_t Argus_ResetCalibrationPixelRangeOffsets(argus_hnd_t *hnd)
Resets the relative pixel offset values for the specified device to the factory calibrated default va...
Argus_SetCalibrationCrosstalkSequenceAmplitudeThreshold
status_t Argus_SetCalibrationCrosstalkSequenceAmplitudeThreshold(argus_hnd_t *hnd, uq12_4_t value)
Sets the max. amplitude threshold for the crosstalk calibration sequence.
Argus_GetCrosstalkVectorTable_Callback
void Argus_GetCrosstalkVectorTable_Callback(argus_cal_xtalk_table_t *xtalk, argus_mode_t const mode)
A callback that returns the external crosstalk vector table.
Argus_GetCalibrationCrosstalkSequenceSampleTime
status_t Argus_GetCalibrationCrosstalkSequenceSampleTime(argus_hnd_t *hnd, uint16_t *value)
Gets the sample time for the crosstalk calibration sequence.
Argus_SetCalibrationGlobalRangeOffsets
status_t Argus_SetCalibrationGlobalRangeOffsets(argus_hnd_t *hnd, q0_15_t offset_low, q0_15_t offset_high)
Sets the global range offset values to a specified device.
Argus_GetCalibrationGlobalRangeOffsets
status_t Argus_GetCalibrationGlobalRangeOffsets(argus_hnd_t *hnd, q0_15_t *offset_low, q0_15_t *offset_high)
Gets the global range offset values from a specified device.
Argus_SetCalibrationPixelRangeOffsets
status_t Argus_SetCalibrationPixelRangeOffsets(argus_hnd_t *hnd, argus_cal_offset_table_t const *value)
Sets the relative pixel offset table to a specified device.
Argus_GetCalibrationCrosstalkSequenceAmplitudeThreshold
status_t Argus_GetCalibrationCrosstalkSequenceAmplitudeThreshold(argus_hnd_t *hnd, uq12_4_t *value)
Gets the max. amplitude threshold for the crosstalk calibration sequence.
Argus_GetCalibrationCrosstalkPixel2Pixel
status_t Argus_GetCalibrationCrosstalkPixel2Pixel(argus_hnd_t *hnd, argus_cal_p2pxtalk_t *value)
Gets the pixel-to-pixel crosstalk compensation parameters from a specified device.
Argus_GetCalibrationGoldenPixel
status_t Argus_GetCalibrationGoldenPixel(argus_hnd_t const *hnd, uint8_t *x, uint8_t *y)
Gets the currently calibrated Golden Pixel coordinates.
Argus_SetCalibrationRangeOffsetSequenceSampleTime
status_t Argus_SetCalibrationRangeOffsetSequenceSampleTime(argus_hnd_t *hnd, uint16_t value)
Sets the sample time for the range offset calibration sequence.
Argus_GetCalibrationCrosstalkVectorTable
status_t Argus_GetCalibrationCrosstalkVectorTable(argus_hnd_t *hnd, argus_cal_xtalk_table_t *value)
Gets the custom crosstalk vector table from a specified device.
Argus_SetCalibrationCrosstalkSequenceSampleTime
status_t Argus_SetCalibrationCrosstalkSequenceSampleTime(argus_hnd_t *hnd, uint16_t value)
Sets the sample time for the crosstalk calibration sequence.
Argus_GetCalibrationRangeOffsetSequenceSampleTime
status_t Argus_GetCalibrationRangeOffsetSequenceSampleTime(argus_hnd_t *hnd, uint16_t *value)
Gets the sample time for the range offset calibration sequence.
Argus_SetCalibrationCrosstalkPixel2Pixel
status_t Argus_SetCalibrationCrosstalkPixel2Pixel(argus_hnd_t *hnd, argus_cal_p2pxtalk_t const *value)
Sets the pixel-to-pixel crosstalk compensation parameters to a specified device.
Argus_ResetCalibrationCrosstalkVectorTable
status_t Argus_ResetCalibrationCrosstalkVectorTable(argus_hnd_t *hnd)
Resets the crosstalk vector table for the specified device to the factory calibrated default values.
Argus_GetPixelRangeOffsets_Callback
void Argus_GetPixelRangeOffsets_Callback(argus_cal_offset_table_t *offsets, argus_mode_t const mode)
A callback that returns the external pixel range offsets.
Argus_GetConfigurationUnambiguousRange
status_t Argus_GetConfigurationUnambiguousRange(argus_hnd_t *hnd, uint32_t *range_mm)
Gets the current unambiguous range in mm.
Argus_GetConfigurationFrameTime
status_t Argus_GetConfigurationFrameTime(argus_hnd_t *hnd, uint32_t *value)
Gets the frame time from a specified device.
Argus_ResetMeasurementMode
status_t Argus_ResetMeasurementMode(argus_hnd_t *hnd)
Resets the measurement mode to a specified device.
Argus_GetConfigurationDFMMode
status_t Argus_GetConfigurationDFMMode(argus_hnd_t *hnd, argus_dfm_mode_t *value)
Gets the Dual Frequency Mode (DFM) from a specified device.
Argus_SetConfigurationDFMMode
status_t Argus_SetConfigurationDFMMode(argus_hnd_t *hnd, argus_dfm_mode_t value)
Sets the Dual Frequency Mode (DFM) to a specified device.
Argus_GetMeasurementMode
status_t Argus_GetMeasurementMode(argus_hnd_t *hnd, argus_mode_t *mode)
Gets the measurement mode from a specified device.
Argus_SetConfigurationShotNoiseMonitorMode
status_t Argus_SetConfigurationShotNoiseMonitorMode(argus_hnd_t *hnd, argus_snm_mode_t value)
Sets the Shot Noise Monitor (SNM) mode to a specified device.
Argus_GetConfigurationCrosstalkMonitorMode
status_t Argus_GetConfigurationCrosstalkMonitorMode(argus_hnd_t *hnd, bool *value)
Gets the Crosstalk Monitor (XTM) mode from a specified device.
Argus_SetConfigurationCrosstalkMonitor
status_t Argus_SetConfigurationCrosstalkMonitor(argus_hnd_t *hnd, argus_cfg_xtm_t const *value)
Sets the crosstalk monitor (XTM) configuration parameters to a specified device.
Argus_SetMeasurementMode
status_t Argus_SetMeasurementMode(argus_hnd_t *hnd, argus_mode_t mode)
Sets the measurement mode to a specified device.
Argus_SetConfigurationCrosstalkMonitorMode
status_t Argus_SetConfigurationCrosstalkMonitorMode(argus_hnd_t *hnd, bool value)
Sets the Crosstalk Monitor (XTM) mode to a specified device.
Argus_GetConfigurationSmartPowerSaveEnabled
status_t Argus_GetConfigurationSmartPowerSaveEnabled(argus_hnd_t *hnd, bool *value)
Gets the smart power save enabled flag from a specified device.
Argus_SetConfigurationDynamicAdaption
status_t Argus_SetConfigurationDynamicAdaption(argus_hnd_t *hnd, argus_cfg_dca_t const *value)
Sets the full DCA module configuration to a specified device.
Argus_GetDefaultMeasurementMode
argus_mode_t Argus_GetDefaultMeasurementMode(argus_module_version_t module)
Gets the default measurement mode for a specified module type.
Argus_GetConfigurationShotNoiseMonitorMode
status_t Argus_GetConfigurationShotNoiseMonitorMode(argus_hnd_t *hnd, argus_snm_mode_t *value)
Gets the Shot Noise Monitor (SNM) mode from a specified device.
Argus_GetConfigurationCrosstalkMonitor
status_t Argus_GetConfigurationCrosstalkMonitor(argus_hnd_t *hnd, argus_cfg_xtm_t *value)
Gets the crosstalk monitor (XTM) configuration parameters from a specified device.
Argus_SetConfigurationFrameTime
status_t Argus_SetConfigurationFrameTime(argus_hnd_t *hnd, uint32_t value)
Sets the frame time to a specified device.
Argus_GetConfigurationNoiseDetectors
status_t Argus_GetConfigurationNoiseDetectors(argus_hnd_t *hnd, argus_cfg_nd_t *value)
Gets the Noise Detectors feature configuration from a specified device.
Argus_SetConfigurationNoiseDetectors
status_t Argus_SetConfigurationNoiseDetectors(argus_hnd_t *hnd, argus_cfg_nd_t const *value)
Sets the Noise Detectors feature configuration to a specified device.
Argus_GetConfigurationDynamicAdaption
status_t Argus_GetConfigurationDynamicAdaption(argus_hnd_t *hnd, argus_cfg_dca_t *value)
Gets the # from a specified device.
Argus_SetConfigurationSmartPowerSaveEnabled
status_t Argus_SetConfigurationSmartPowerSaveEnabled(argus_hnd_t *hnd, bool value)
Sets the smart power save enabled flag to a specified device.
Argus_SetConfigurationPixelBinning
status_t Argus_SetConfigurationPixelBinning(argus_hnd_t *hnd, argus_cfg_pba_t const *value)
Sets the pixel binning configuration parameters to a specified device.
Argus_GetConfigurationPixelBinning
status_t Argus_GetConfigurationPixelBinning(argus_hnd_t *hnd, argus_cfg_pba_t *value)
Gets the pixel binning configuration parameters from a specified device.
argus_dfm_mode_t
argus_dfm_mode_t
Definition argus_dfm.h:71
q9_22_t
int32_t q9_22_t
Signed fixed point number: Q9.22.
Definition fp_def.h:538
q0_15_t
int16_t q0_15_t
Signed fixed point number: Q0.15.
Definition fp_def.h:381
uq12_4_t
uint16_t uq12_4_t
Unsigned fixed point number: UQ12.4.
Definition fp_def.h:231
Argus_EvaluateData
status_t Argus_EvaluateData(argus_hnd_t *hnd, argus_results_t *res)
Evaluates measurement data from the raw sensor readout data.
Argus_Abort
status_t Argus_Abort(argus_hnd_t *hnd)
Stops the currently ongoing measurements and SPI activity immediately.
Argus_TriggerMeasurement
status_t Argus_TriggerMeasurement(argus_hnd_t *hnd, argus_measurement_ready_callback_t cb)
Triggers a single measurement frame asynchronously.
Argus_StopMeasurementTimer
status_t Argus_StopMeasurementTimer(argus_hnd_t *hnd)
Stops the timer based measurement cycle.
Argus_IsDataEvaluationPending
bool Argus_IsDataEvaluationPending(argus_hnd_t *hnd)
Determines whether a data evaluation is pending.
Argus_EvaluateDataDebug
status_t Argus_EvaluateDataDebug(argus_hnd_t *hnd, argus_results_t *res, argus_results_debug_t *dbg)
Evaluates measurement data from the raw sensor readout data.
Argus_ExecuteAbsoluteRangeOffsetCalibrationSequence
status_t Argus_ExecuteAbsoluteRangeOffsetCalibrationSequence(argus_hnd_t *hnd, q9_22_t targetRange)
Executes an absolute range offset calibration measurement.
Argus_GetStatus
status_t Argus_GetStatus(argus_hnd_t *hnd)
Checks the state of the device/driver.
Argus_StartTeachInMode
status_t Argus_StartTeachInMode(argus_hnd_t *hnd)
Starts the teach-in measurement mode.
Argus_StartMeasurementTimer
status_t Argus_StartMeasurementTimer(argus_hnd_t *hnd, argus_measurement_ready_callback_t cb)
Starts the timer based measurement cycle asynchronously.
Argus_ExecuteRelativeRangeOffsetCalibrationSequence
status_t Argus_ExecuteRelativeRangeOffsetCalibrationSequence(argus_hnd_t *hnd)
Executes a relative range offset calibration measurement.
Argus_IsTimerMeasurementActive
bool Argus_IsTimerMeasurementActive(argus_hnd_t *hnd)
Determines if the device if active with timer based measurements.
Argus_ExecuteXtalkCalibrationSequence
status_t Argus_ExecuteXtalkCalibrationSequence(argus_hnd_t *hnd)
Executes a crosstalk calibration measurement.
Argus_StopTeachInMode
status_t Argus_StopTeachInMode(argus_hnd_t *hnd)
Stops the teach-in measurement mode.
Argus_Ping
status_t Argus_Ping(argus_hnd_t *hnd)
Tests the connection to the device by sending a ping message.
argus_snm_mode_t
argus_snm_mode_t
Definition argus_snm.h:66
status_t
int32_t status_t
Type used for all status and error return values.
Definition argus_status.h:70
hnd
argus_hnd_t * hnd
Definition main.c:100
argus_cal_p2pxtalk_t
Pixel-To-Pixel Crosstalk Compensation Parameters.
Definition argus_xtalk.h:201
argus_cfg_dca_t
Dynamic Configuration Adaption (DCA) Parameters.
Definition argus_dca.h:372
argus_cfg_nd_t
Noise Detectors Parameters for Saturation Detector and for Optical Disturber Detector.
Definition argus_nd.h:85
argus_cfg_pba_t
The pixel binning algorithm settings data structure.
Definition argus_pba.h:208
argus_cfg_xtm_t
The configuration of the shot noise monitor task.
Definition argus_xtalk.h:96
argus_results_debug_t
The debug data of measurement results data structure.
Definition argus_res.h:144
argus_results_t
The measurement results data structure.
Definition argus_res.h:216
argus_cal_offset_table_t
Pixel Range Offset Table.
Definition argus_offset.h:55
argus_cal_xtalk_table_t
Pixel Crosstalk Vector Table.
Definition argus_xtalk.h:77