yoctolib-esm

/********************************************************************* * * $Id: svn_id $ * * Implements the high-level API for MultiCellWeighScale 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'; /** * YMultiCellWeighScale Class: multi-cell weighing scale sensor control interface, available for * instance in the Yocto-MaxiBridge * * The YMultiCellWeighScale class provides a weight measurement from a set of ratiometric * sensors. It can be used to control the bridge excitation parameters, in order to avoid * measure shifts caused by temperature variation in the electronics, and can also * automatically apply an additional correction factor based on temperature to * compensate for offsets in the load cells themselves. */ export declare class YMultiCellWeighScale extends YSensor { _className: string; _cellCount: number; _externalSense: YMultiCellWeighScale.EXTERNALSENSE; _excitation: YMultiCellWeighScale.EXCITATION; _tempAvgAdaptRatio: number; _tempChgAdaptRatio: number; _compTempAvg: number; _compTempChg: number; _compensation: number; _zeroTracking: number; _command: string; _valueCallbackMultiCellWeighScale: YMultiCellWeighScale.ValueCallback | null; _timedReportCallbackMultiCellWeighScale: YMultiCellWeighScale.TimedReportCallback | null; readonly CELLCOUNT_INVALID: number; readonly EXTERNALSENSE_FALSE: YMultiCellWeighScale.EXTERNALSENSE; readonly EXTERNALSENSE_TRUE: YMultiCellWeighScale.EXTERNALSENSE; readonly EXTERNALSENSE_INVALID: YMultiCellWeighScale.EXTERNALSENSE; readonly EXCITATION_OFF: YMultiCellWeighScale.EXCITATION; readonly EXCITATION_DC: YMultiCellWeighScale.EXCITATION; readonly EXCITATION_AC: YMultiCellWeighScale.EXCITATION; readonly EXCITATION_INVALID: YMultiCellWeighScale.EXCITATION; readonly TEMPAVGADAPTRATIO_INVALID: number; readonly TEMPCHGADAPTRATIO_INVALID: number; readonly COMPTEMPAVG_INVALID: number; readonly COMPTEMPCHG_INVALID: number; readonly COMPENSATION_INVALID: number; readonly ZEROTRACKING_INVALID: number; readonly COMMAND_INVALID: string; static readonly CELLCOUNT_INVALID: number; static readonly EXTERNALSENSE_FALSE: YMultiCellWeighScale.EXTERNALSENSE; static readonly EXTERNALSENSE_TRUE: YMultiCellWeighScale.EXTERNALSENSE; static readonly EXTERNALSENSE_INVALID: YMultiCellWeighScale.EXTERNALSENSE; static readonly EXCITATION_OFF: YMultiCellWeighScale.EXCITATION; static readonly EXCITATION_DC: YMultiCellWeighScale.EXCITATION; static readonly EXCITATION_AC: YMultiCellWeighScale.EXCITATION; static readonly EXCITATION_INVALID: YMultiCellWeighScale.EXCITATION; static readonly TEMPAVGADAPTRATIO_INVALID: number; static readonly TEMPCHGADAPTRATIO_INVALID: number; static readonly COMPTEMPAVG_INVALID: number; static readonly COMPTEMPCHG_INVALID: number; static readonly COMPENSATION_INVALID: number; static readonly ZEROTRACKING_INVALID: number; static readonly COMMAND_INVALID: string; constructor(yapi: YAPIContext, func: string); imm_parseAttr(name: string, val: any): number; /** * Changes the measuring unit for the weight. * Remember to call the saveToFlash() method of the module if the * modification must be kept. * * @param newval : a string corresponding to the measuring unit for the weight * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_unit(newval: string): Promise<number>; /** * Returns the number of load cells in use. * * @return an integer corresponding to the number of load cells in use * * On failure, throws an exception or returns YMultiCellWeighScale.CELLCOUNT_INVALID. */ get_cellCount(): Promise<number>; /** * Changes the number of load cells in use. Remember to call the saveToFlash() * method of the module if the modification must be kept. * * @param newval : an integer corresponding to the number of load cells in use * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_cellCount(newval: number): Promise<number>; /** * Returns true if entry 4 is used as external sense for 6-wires load cells. * * @return either YMultiCellWeighScale.EXTERNALSENSE_FALSE or YMultiCellWeighScale.EXTERNALSENSE_TRUE, * according to true if entry 4 is used as external sense for 6-wires load cells * * On failure, throws an exception or returns YMultiCellWeighScale.EXTERNALSENSE_INVALID. */ get_externalSense(): Promise<YMultiCellWeighScale.EXTERNALSENSE>; /** * Changes the configuration to tell if entry 4 is used as external sense for * 6-wires load cells. Remember to call the saveToFlash() method of the * module if the modification must be kept. * * @param newval : either YMultiCellWeighScale.EXTERNALSENSE_FALSE or * YMultiCellWeighScale.EXTERNALSENSE_TRUE, according to the configuration to tell if entry 4 is used * as external sense for * 6-wires load cells * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_externalSense(newval: YMultiCellWeighScale.EXTERNALSENSE): Promise<number>; /** * Returns the current load cell bridge excitation method. * * @return a value among YMultiCellWeighScale.EXCITATION_OFF, YMultiCellWeighScale.EXCITATION_DC and * YMultiCellWeighScale.EXCITATION_AC corresponding to the current load cell bridge excitation method * * On failure, throws an exception or returns YMultiCellWeighScale.EXCITATION_INVALID. */ get_excitation(): Promise<YMultiCellWeighScale.EXCITATION>; /** * Changes the current load cell bridge excitation method. * Remember to call the saveToFlash() method of the module if the * modification must be kept. * * @param newval : a value among YMultiCellWeighScale.EXCITATION_OFF, * YMultiCellWeighScale.EXCITATION_DC and YMultiCellWeighScale.EXCITATION_AC corresponding to the * current load cell bridge excitation method * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_excitation(newval: YMultiCellWeighScale.EXCITATION): Promise<number>; /** * Changes the averaged temperature update rate, in per mille. * The purpose of this adaptation ratio is to model the thermal inertia of the load cell. * The averaged temperature is updated every 10 seconds, by applying this adaptation rate * to the difference between the measures ambient temperature and the current compensation * temperature. The standard rate is 0.2 per mille, and the maximal rate is 65 per mille. * Remember to call the saveToFlash() method of the module if the * modification must be kept. * * @param newval : a floating point number corresponding to the averaged temperature update rate, in per mille * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_tempAvgAdaptRatio(newval: number): Promise<number>; /** * Returns the averaged temperature update rate, in per mille. * The purpose of this adaptation ratio is to model the thermal inertia of the load cell. * The averaged temperature is updated every 10 seconds, by applying this adaptation rate * to the difference between the measures ambient temperature and the current compensation * temperature. The standard rate is 0.2 per mille, and the maximal rate is 65 per mille. * * @return a floating point number corresponding to the averaged temperature update rate, in per mille * * On failure, throws an exception or returns YMultiCellWeighScale.TEMPAVGADAPTRATIO_INVALID. */ get_tempAvgAdaptRatio(): Promise<number>; /** * Changes the temperature change update rate, in per mille. * The temperature change is updated every 10 seconds, by applying this adaptation rate * to the difference between the measures ambient temperature and the current temperature used for * change compensation. The standard rate is 0.6 per mille, and the maximal rate is 65 per mille. * Remember to call the saveToFlash() method of the module if the * modification must be kept. * * @param newval : a floating point number corresponding to the temperature change update rate, in per mille * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_tempChgAdaptRatio(newval: number): Promise<number>; /** * Returns the temperature change update rate, in per mille. * The temperature change is updated every 10 seconds, by applying this adaptation rate * to the difference between the measures ambient temperature and the current temperature used for * change compensation. The standard rate is 0.6 per mille, and the maximal rate is 65 per mille. * * @return a floating point number corresponding to the temperature change update rate, in per mille * * On failure, throws an exception or returns YMultiCellWeighScale.TEMPCHGADAPTRATIO_INVALID. */ get_tempChgAdaptRatio(): Promise<number>; /** * Returns the current averaged temperature, used for thermal compensation. * * @return a floating point number corresponding to the current averaged temperature, used for thermal compensation * * On failure, throws an exception or returns YMultiCellWeighScale.COMPTEMPAVG_INVALID. */ get_compTempAvg(): Promise<number>; /** * Returns the current temperature variation, used for thermal compensation. * * @return a floating point number corresponding to the current temperature variation, used for * thermal compensation * * On failure, throws an exception or returns YMultiCellWeighScale.COMPTEMPCHG_INVALID. */ get_compTempChg(): Promise<number>; /** * Returns the current current thermal compensation value. * * @return a floating point number corresponding to the current current thermal compensation value * * On failure, throws an exception or returns YMultiCellWeighScale.COMPENSATION_INVALID. */ get_compensation(): Promise<number>; /** * Changes the zero tracking threshold value. When this threshold is larger than * zero, any measure under the threshold will automatically be ignored and the * zero compensation will be updated. * Remember to call the saveToFlash() method of the module if the * modification must be kept. * * @param newval : a floating point number corresponding to the zero tracking threshold value * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_zeroTracking(newval: number): Promise<number>; /** * Returns the zero tracking threshold value. When this threshold is larger than * zero, any measure under the threshold will automatically be ignored and the * zero compensation will be updated. * * @return a floating point number corresponding to the zero tracking threshold value * * On failure, throws an exception or returns YMultiCellWeighScale.ZEROTRACKING_INVALID. */ get_zeroTracking(): Promise<number>; get_command(): Promise<string>; set_command(newval: string): Promise<number>; /** * Retrieves a multi-cell weighing scale sensor 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 multi-cell weighing scale sensor is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YMultiCellWeighScale.isOnline() to test if the multi-cell weighing scale sensor is * indeed online at a given time. In case of ambiguity when looking for * a multi-cell weighing scale sensor 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 multi-cell weighing scale sensor, for instance * YWMBRDG1.multiCellWeighScale. * * @return a YMultiCellWeighScale object allowing you to drive the multi-cell weighing scale sensor. */ static FindMultiCellWeighScale(func: string): YMultiCellWeighScale; /** * Retrieves a multi-cell weighing scale sensor 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 multi-cell weighing scale sensor is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YMultiCellWeighScale.isOnline() to test if the multi-cell weighing scale sensor is * indeed online at a given time. In case of ambiguity when looking for * a multi-cell weighing scale sensor 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 multi-cell weighing scale sensor, for instance * YWMBRDG1.multiCellWeighScale. * * @return a YMultiCellWeighScale object allowing you to drive the multi-cell weighing scale sensor. */ static FindMultiCellWeighScaleInContext(yctx: YAPIContext, func: string): YMultiCellWeighScale; /** * 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: YMultiCellWeighScale.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: YMultiCellWeighScale.TimedReportCallback | null): Promise<number>; _invokeTimedReportCallback(value: YMeasure): Promise<number>; /** * Adapts the load cell signal bias (stored in the corresponding genericSensor) * so that the current signal corresponds to a zero weight. Remember to call the * saveToFlash() method of the module if the modification must be kept. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ tare(): Promise<number>; /** * Configures the load cells span parameters (stored in the corresponding genericSensors) * so that the current signal corresponds to the specified reference weight. * * @param currWeight : reference weight presently on the load cell. * @param maxWeight : maximum weight to be expected on the load cell. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ setupSpan(currWeight: number, maxWeight: number): Promise<number>; /** * Continues the enumeration of multi-cell weighing scale sensors started using yFirstMultiCellWeighScale(). * Caution: You can't make any assumption about the returned multi-cell weighing scale sensors order. * If you want to find a specific a multi-cell weighing scale sensor, use * MultiCellWeighScale.findMultiCellWeighScale() * and a hardwareID or a logical name. * * @return a pointer to a YMultiCellWeighScale object, corresponding to * a multi-cell weighing scale sensor currently online, or a null pointer * if there are no more multi-cell weighing scale sensors to enumerate. */ nextMultiCellWeighScale(): YMultiCellWeighScale | null; /** * Starts the enumeration of multi-cell weighing scale sensors currently accessible. * Use the method YMultiCellWeighScale.nextMultiCellWeighScale() to iterate on * next multi-cell weighing scale sensors. * * @return a pointer to a YMultiCellWeighScale object, corresponding to * the first multi-cell weighing scale sensor currently online, or a null pointer * if there are none. */ static FirstMultiCellWeighScale(): YMultiCellWeighScale | null; /** * Starts the enumeration of multi-cell weighing scale sensors currently accessible. * Use the method YMultiCellWeighScale.nextMultiCellWeighScale() to iterate on * next multi-cell weighing scale sensors. * * @param yctx : a YAPI context. * * @return a pointer to a YMultiCellWeighScale object, corresponding to * the first multi-cell weighing scale sensor currently online, or a null pointer * if there are none. */ static FirstMultiCellWeighScaleInContext(yctx: YAPIContext): YMultiCellWeighScale | null; } export declare namespace YMultiCellWeighScale { const enum EXTERNALSENSE { FALSE = 0, TRUE = 1, INVALID = -1 } const enum EXCITATION { OFF = 0, DC = 1, AC = 2, INVALID = -1 } interface ValueCallback { (func: YMultiCellWeighScale, value: string): void; } interface TimedReportCallback { (func: YMultiCellWeighScale, measure: YMeasure): void; } }