yoctolib-esm

/********************************************************************* * * $Id: yocto_gyro.ts 63327 2024-11-13 09:35:03Z seb $ * * Implements the high-level API for Qt functions * * - - - - - - - - - License information: - - - - - - - - - * * Copyright (C) 2011 and beyond by Yoctopuce Sarl, Switzerland. * * Yoctopuce Sarl (hereafter Licensor) grants to you a perpetual * non-exclusive license to use, modify, copy and integrate this * file into your software for the sole purpose of interfacing * with Yoctopuce products. * * You may reproduce and distribute copies of this file in * source or object form, as long as the sole purpose of this * code is to interface with Yoctopuce products. You must retain * this notice in the distributed source file. * * You should refer to Yoctopuce General Terms and Conditions * for additional information regarding your rights and * obligations. * * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED 'AS IS' WITHOUT * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING * WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS * FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO * EVENT SHALL LICENSOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL, * INDIRECT OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, * COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR * SERVICES, ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT * LIMITED TO ANY DEFENSE THEREOF), ANY CLAIMS FOR INDEMNITY OR * CONTRIBUTION, OR OTHER SIMILAR COSTS, WHETHER ASSERTED ON THE * BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE), BREACH OF * WARRANTY, OR OTHERWISE. * *********************************************************************/ import { YAPIContext, YSensor, YMeasure } from './yocto_api.js'; /** * YQt Class: Base interface to access quaternion components, available for instance in the Yocto-3D-V2 * * The YQt class provides direct access to the 3D attitude estimation * provided by Yoctopuce inertial sensors. The four instances of YQt * provide direct access to the individual quaternion components representing the * orientation. It is usually not needed to use the YQt class * directly, as the YGyro class provides a more convenient higher-level * interface. */ export declare class YQt extends YSensor { _className: string; _valueCallbackQt: YQt.ValueCallback | null; _timedReportCallbackQt: YQt.TimedReportCallback | null; constructor(yapi: YAPIContext, func: string); /** * Retrieves a quaternion component for a given identifier. * The identifier can be specified using several formats: * * - FunctionLogicalName * - ModuleSerialNumber.FunctionIdentifier * - ModuleSerialNumber.FunctionLogicalName * - ModuleLogicalName.FunctionIdentifier * - ModuleLogicalName.FunctionLogicalName * * * This function does not require that the quaternion component is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YQt.isOnline() to test if the quaternion component is * indeed online at a given time. In case of ambiguity when looking for * a quaternion component by logical name, no error is notified: the first instance * found is returned. The search is performed first by hardware name, * then by logical name. * * If a call to this object's is_online() method returns FALSE although * you are certain that the matching device is plugged, make sure that you did * call registerHub() at application initialization time. * * @param func : a string that uniquely characterizes the quaternion component, for instance * Y3DMK002.qt1. * * @return a YQt object allowing you to drive the quaternion component. */ static FindQt(func: string): YQt; /** * Retrieves a quaternion component for a given identifier in a YAPI context. * The identifier can be specified using several formats: * * - FunctionLogicalName * - ModuleSerialNumber.FunctionIdentifier * - ModuleSerialNumber.FunctionLogicalName * - ModuleLogicalName.FunctionIdentifier * - ModuleLogicalName.FunctionLogicalName * * * This function does not require that the quaternion component is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YQt.isOnline() to test if the quaternion component is * indeed online at a given time. In case of ambiguity when looking for * a quaternion component by logical name, no error is notified: the first instance * found is returned. The search is performed first by hardware name, * then by logical name. * * @param yctx : a YAPI context * @param func : a string that uniquely characterizes the quaternion component, for instance * Y3DMK002.qt1. * * @return a YQt object allowing you to drive the quaternion component. */ static FindQtInContext(yctx: YAPIContext, func: string): YQt; /** * Registers the callback function that is invoked on every change of advertised value. * The callback is invoked only during the execution of ySleep or yHandleEvents. * This provides control over the time when the callback is triggered. For good responsiveness, remember to call * one of these two functions periodically. To unregister a callback, pass a null pointer as argument. * * @param callback : the callback function to call, or a null pointer. The callback function should take two * arguments: the function object of which the value has changed, and the character string describing * the new advertised value. * @noreturn */ registerValueCallback(callback: YQt.ValueCallback | null): Promise<number>; _invokeValueCallback(value: string): Promise<number>; /** * Registers the callback function that is invoked on every periodic timed notification. * The callback is invoked only during the execution of ySleep or yHandleEvents. * This provides control over the time when the callback is triggered. For good responsiveness, remember to call * one of these two functions periodically. To unregister a callback, pass a null pointer as argument. * * @param callback : the callback function to call, or a null pointer. The callback function should take two * arguments: the function object of which the value has changed, and an YMeasure object describing * the new advertised value. * @noreturn */ registerTimedReportCallback(callback: YQt.TimedReportCallback | null): Promise<number>; _invokeTimedReportCallback(value: YMeasure): Promise<number>; /** * Continues the enumeration of quaternion components started using yFirstQt(). * Caution: You can't make any assumption about the returned quaternion components order. * If you want to find a specific a quaternion component, use Qt.findQt() * and a hardwareID or a logical name. * * @return a pointer to a YQt object, corresponding to * a quaternion component currently online, or a null pointer * if there are no more quaternion components to enumerate. */ nextQt(): YQt | null; /** * Starts the enumeration of quaternion components currently accessible. * Use the method YQt.nextQt() to iterate on * next quaternion components. * * @return a pointer to a YQt object, corresponding to * the first quaternion component currently online, or a null pointer * if there are none. */ static FirstQt(): YQt | null; /** * Starts the enumeration of quaternion components currently accessible. * Use the method YQt.nextQt() to iterate on * next quaternion components. * * @param yctx : a YAPI context. * * @return a pointer to a YQt object, corresponding to * the first quaternion component currently online, or a null pointer * if there are none. */ static FirstQtInContext(yctx: YAPIContext): YQt | null; } export declare namespace YQt { interface ValueCallback { (func: YQt, value: string): void; } interface TimedReportCallback { (func: YQt, measure: YMeasure): void; } } /** * YGyro Class: gyroscope control interface, available for instance in the Yocto-3D-V2 * * The YGyro class allows you to read and configure Yoctopuce gyroscopes. * It inherits from YSensor class the core functions to read measurements, * to register callback functions, and to access the autonomous datalogger. * This class adds the possibility to access x, y and z components of the rotation * vector separately, as well as the possibility to deal with quaternion-based * orientation estimates. */ /** @extends {YFunction} **/ export declare class YGyro extends YSensor { _className: string; _bandwidth: number; _xValue: number; _yValue: number; _zValue: number; _valueCallbackGyro: YGyro.ValueCallback | null; _timedReportCallbackGyro: YGyro.TimedReportCallback | null; _qt_stamp: number; _qt_w: YQt; _qt_x: YQt; _qt_y: YQt; _qt_z: YQt; _w: number; _x: number; _y: number; _z: number; _angles_stamp: number; _head: number; _pitch: number; _roll: number; _quatCallback: YGyro.YQuatCallback | null; _anglesCallback: YGyro.YAnglesCallback | null; readonly BANDWIDTH_INVALID: number; readonly XVALUE_INVALID: number; readonly YVALUE_INVALID: number; readonly ZVALUE_INVALID: number; static readonly BANDWIDTH_INVALID: number; static readonly XVALUE_INVALID: number; static readonly YVALUE_INVALID: number; static readonly ZVALUE_INVALID: number; constructor(yapi: YAPIContext, func: string); imm_parseAttr(name: string, val: any): number; /** * Returns the measure update frequency, measured in Hz. * * @return an integer corresponding to the measure update frequency, measured in Hz * * On failure, throws an exception or returns YGyro.BANDWIDTH_INVALID. */ get_bandwidth(): Promise<number>; /** * Changes the measure update frequency, measured in Hz. When the * frequency is lower, the device performs averaging. * Remember to call the saveToFlash() * method of the module if the modification must be kept. * * @param newval : an integer corresponding to the measure update frequency, measured in Hz * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_bandwidth(newval: number): Promise<number>; /** * Returns the angular velocity around the X axis of the device, as a floating point number. * * @return a floating point number corresponding to the angular velocity around the X axis of the * device, as a floating point number * * On failure, throws an exception or returns YGyro.XVALUE_INVALID. */ get_xValue(): Promise<number>; /** * Returns the angular velocity around the Y axis of the device, as a floating point number. * * @return a floating point number corresponding to the angular velocity around the Y axis of the * device, as a floating point number * * On failure, throws an exception or returns YGyro.YVALUE_INVALID. */ get_yValue(): Promise<number>; /** * Returns the angular velocity around the Z axis of the device, as a floating point number. * * @return a floating point number corresponding to the angular velocity around the Z axis of the * device, as a floating point number * * On failure, throws an exception or returns YGyro.ZVALUE_INVALID. */ get_zValue(): Promise<number>; /** * Retrieves a gyroscope for a given identifier. * The identifier can be specified using several formats: * * - FunctionLogicalName * - ModuleSerialNumber.FunctionIdentifier * - ModuleSerialNumber.FunctionLogicalName * - ModuleLogicalName.FunctionIdentifier * - ModuleLogicalName.FunctionLogicalName * * * This function does not require that the gyroscope is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YGyro.isOnline() to test if the gyroscope is * indeed online at a given time. In case of ambiguity when looking for * a gyroscope by logical name, no error is notified: the first instance * found is returned. The search is performed first by hardware name, * then by logical name. * * If a call to this object's is_online() method returns FALSE although * you are certain that the matching device is plugged, make sure that you did * call registerHub() at application initialization time. * * @param func : a string that uniquely characterizes the gyroscope, for instance * Y3DMK002.gyro. * * @return a YGyro object allowing you to drive the gyroscope. */ static FindGyro(func: string): YGyro; /** * Retrieves a gyroscope for a given identifier in a YAPI context. * The identifier can be specified using several formats: * * - FunctionLogicalName * - ModuleSerialNumber.FunctionIdentifier * - ModuleSerialNumber.FunctionLogicalName * - ModuleLogicalName.FunctionIdentifier * - ModuleLogicalName.FunctionLogicalName * * * This function does not require that the gyroscope is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YGyro.isOnline() to test if the gyroscope is * indeed online at a given time. In case of ambiguity when looking for * a gyroscope by logical name, no error is notified: the first instance * found is returned. The search is performed first by hardware name, * then by logical name. * * @param yctx : a YAPI context * @param func : a string that uniquely characterizes the gyroscope, for instance * Y3DMK002.gyro. * * @return a YGyro object allowing you to drive the gyroscope. */ static FindGyroInContext(yctx: YAPIContext, func: string): YGyro; /** * Registers the callback function that is invoked on every change of advertised value. * The callback is invoked only during the execution of ySleep or yHandleEvents. * This provides control over the time when the callback is triggered. For good responsiveness, remember to call * one of these two functions periodically. To unregister a callback, pass a null pointer as argument. * * @param callback : the callback function to call, or a null pointer. The callback function should take two * arguments: the function object of which the value has changed, and the character string describing * the new advertised value. * @noreturn */ registerValueCallback(callback: YGyro.ValueCallback | null): Promise<number>; _invokeValueCallback(value: string): Promise<number>; /** * Registers the callback function that is invoked on every periodic timed notification. * The callback is invoked only during the execution of ySleep or yHandleEvents. * This provides control over the time when the callback is triggered. For good responsiveness, remember to call * one of these two functions periodically. To unregister a callback, pass a null pointer as argument. * * @param callback : the callback function to call, or a null pointer. The callback function should take two * arguments: the function object of which the value has changed, and an YMeasure object describing * the new advertised value. * @noreturn */ registerTimedReportCallback(callback: YGyro.TimedReportCallback | null): Promise<number>; _invokeTimedReportCallback(value: YMeasure): Promise<number>; _loadQuaternion(): Promise<number>; _loadAngles(): Promise<number>; /** * Returns the estimated roll angle, based on the integration of * gyroscopic measures combined with acceleration and * magnetic field measurements. * The axis corresponding to the roll angle can be mapped to any * of the device X, Y or Z physical directions using methods of * the class YRefFrame. * * @return a floating-point number corresponding to roll angle * in degrees, between -180 and +180. */ get_roll(): Promise<number>; /** * Returns the estimated pitch angle, based on the integration of * gyroscopic measures combined with acceleration and * magnetic field measurements. * The axis corresponding to the pitch angle can be mapped to any * of the device X, Y or Z physical directions using methods of * the class YRefFrame. * * @return a floating-point number corresponding to pitch angle * in degrees, between -90 and +90. */ get_pitch(): Promise<number>; /** * Returns the estimated heading angle, based on the integration of * gyroscopic measures combined with acceleration and * magnetic field measurements. * The axis corresponding to the heading can be mapped to any * of the device X, Y or Z physical directions using methods of * the class YRefFrame. * * @return a floating-point number corresponding to heading * in degrees, between 0 and 360. */ get_heading(): Promise<number>; /** * Returns the w component (real part) of the quaternion * describing the device estimated orientation, based on the * integration of gyroscopic measures combined with acceleration and * magnetic field measurements. * * @return a floating-point number corresponding to the w * component of the quaternion. */ get_quaternionW(): Promise<number>; /** * Returns the x component of the quaternion * describing the device estimated orientation, based on the * integration of gyroscopic measures combined with acceleration and * magnetic field measurements. The x component is * mostly correlated with rotations on the roll axis. * * @return a floating-point number corresponding to the x * component of the quaternion. */ get_quaternionX(): Promise<number>; /** * Returns the y component of the quaternion * describing the device estimated orientation, based on the * integration of gyroscopic measures combined with acceleration and * magnetic field measurements. The y component is * mostly correlated with rotations on the pitch axis. * * @return a floating-point number corresponding to the y * component of the quaternion. */ get_quaternionY(): Promise<number>; /** * Returns the x component of the quaternion * describing the device estimated orientation, based on the * integration of gyroscopic measures combined with acceleration and * magnetic field measurements. The x component is * mostly correlated with changes of heading. * * @return a floating-point number corresponding to the z * component of the quaternion. */ get_quaternionZ(): Promise<number>; /** * Registers a callback function that will be invoked each time that the estimated * device orientation has changed. The call frequency is typically around 95Hz during a move. * The callback is invoked only during the execution of ySleep or yHandleEvents. * This provides control over the time when the callback is triggered. * For good responsiveness, remember to call one of these two functions periodically. * To unregister a callback, pass a null pointer as argument. * * @param callback : the callback function to invoke, or a null pointer. * The callback function should take five arguments: * the YGyro object of the turning device, and the floating * point values of the four components w, x, y and z * (as floating-point numbers). * @noreturn */ registerQuaternionCallback(callback: YGyro.YQuatCallback | null): Promise<number>; /** * Registers a callback function that will be invoked each time that the estimated * device orientation has changed. The call frequency is typically around 95Hz during a move. * The callback is invoked only during the execution of ySleep or yHandleEvents. * This provides control over the time when the callback is triggered. * For good responsiveness, remember to call one of these two functions periodically. * To unregister a callback, pass a null pointer as argument. * * @param callback : the callback function to invoke, or a null pointer. * The callback function should take four arguments: * the YGyro object of the turning device, and the floating * point values of the three angles roll, pitch and heading * in degrees (as floating-point numbers). * @noreturn */ registerAnglesCallback(callback: YGyro.YAnglesCallback | null): Promise<number>; _invokeGyroCallbacks(qtIndex: number, qtValue: number): Promise<number>; /** * Continues the enumeration of gyroscopes started using yFirstGyro(). * Caution: You can't make any assumption about the returned gyroscopes order. * If you want to find a specific a gyroscope, use Gyro.findGyro() * and a hardwareID or a logical name. * * @return a pointer to a YGyro object, corresponding to * a gyroscope currently online, or a null pointer * if there are no more gyroscopes to enumerate. */ nextGyro(): YGyro | null; /** * Starts the enumeration of gyroscopes currently accessible. * Use the method YGyro.nextGyro() to iterate on * next gyroscopes. * * @return a pointer to a YGyro object, corresponding to * the first gyro currently online, or a null pointer * if there are none. */ static FirstGyro(): YGyro | null; /** * Starts the enumeration of gyroscopes currently accessible. * Use the method YGyro.nextGyro() to iterate on * next gyroscopes. * * @param yctx : a YAPI context. * * @return a pointer to a YGyro object, corresponding to * the first gyro currently online, or a null pointer * if there are none. */ static FirstGyroInContext(yctx: YAPIContext): YGyro | null; } export declare namespace YGyro { interface ValueCallback { (func: YGyro, value: string): void; } interface TimedReportCallback { (func: YGyro, measure: YMeasure): void; } interface YQuatCallback { (func: YGyro, w: number, x: number, y: number, z: number): void; } interface YAnglesCallback { (func: YGyro, roll: number, pitch: number, head: number): void; } }