yoctolib-esm

/********************************************************************* * * $Id: svn_id $ * * Implements the high-level API for WeighScale 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'; /** * YWeighScale Class: weighing scale sensor control interface, available for instance in the * Yocto-Bridge or the Yocto-MaxiBridge * * The YWeighScale class provides a weight measurement from a ratiometric sensor. * 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 cell itself. */ export declare class YWeighScale extends YSensor { _className: string; _excitation: YWeighScale.EXCITATION; _tempAvgAdaptRatio: number; _tempChgAdaptRatio: number; _compTempAvg: number; _compTempChg: number; _compensation: number; _zeroTracking: number; _command: string; _valueCallbackWeighScale: YWeighScale.ValueCallback | null; _timedReportCallbackWeighScale: YWeighScale.TimedReportCallback | null; readonly EXCITATION_OFF: YWeighScale.EXCITATION; readonly EXCITATION_DC: YWeighScale.EXCITATION; readonly EXCITATION_AC: YWeighScale.EXCITATION; readonly EXCITATION_INVALID: YWeighScale.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 EXCITATION_OFF: YWeighScale.EXCITATION; static readonly EXCITATION_DC: YWeighScale.EXCITATION; static readonly EXCITATION_AC: YWeighScale.EXCITATION; static readonly EXCITATION_INVALID: YWeighScale.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 current load cell bridge excitation method. * * @return a value among YWeighScale.EXCITATION_OFF, YWeighScale.EXCITATION_DC and * YWeighScale.EXCITATION_AC corresponding to the current load cell bridge excitation method * * On failure, throws an exception or returns YWeighScale.EXCITATION_INVALID. */ get_excitation(): Promise<YWeighScale.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 YWeighScale.EXCITATION_OFF, YWeighScale.EXCITATION_DC and * YWeighScale.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: YWeighScale.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 YWeighScale.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 YWeighScale.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 YWeighScale.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 YWeighScale.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 YWeighScale.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 YWeighScale.ZEROTRACKING_INVALID. */ get_zeroTracking(): Promise<number>; get_command(): Promise<string>; set_command(newval: string): Promise<number>; /** * Retrieves a 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 weighing scale sensor is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YWeighScale.isOnline() to test if the weighing scale sensor is * indeed online at a given time. In case of ambiguity when looking for * a 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 weighing scale sensor, for instance * YWBRIDG1.weighScale1. * * @return a YWeighScale object allowing you to drive the weighing scale sensor. */ static FindWeighScale(func: string): YWeighScale; /** * Retrieves a 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 weighing scale sensor is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YWeighScale.isOnline() to test if the weighing scale sensor is * indeed online at a given time. In case of ambiguity when looking for * a 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 weighing scale sensor, for instance * YWBRIDG1.weighScale1. * * @return a YWeighScale object allowing you to drive the weighing scale sensor. */ static FindWeighScaleInContext(yctx: YAPIContext, func: string): YWeighScale; /** * 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: YWeighScale.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: YWeighScale.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 cell span parameters (stored in the corresponding genericSensor) * 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>; setCompensationTable(tableIndex: number, tempValues: number[], compValues: number[]): Promise<number>; loadCompensationTable(tableIndex: number, tempValues: number[], compValues: number[]): Promise<number>; /** * Records a weight offset thermal compensation table, in order to automatically correct the * measured weight based on the averaged compensation temperature. * The weight correction will be applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, corresponding to all averaged * temperatures for which an offset correction is specified. * @param compValues : array of floating point numbers, corresponding to the offset correction * to apply for each of the temperature included in the first * argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_offsetAvgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Retrieves the weight offset thermal compensation table previously configured using the * set_offsetAvgCompensationTable function. * The weight correction is applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, that is filled by the function * with all averaged temperatures for which an offset correction is specified. * @param compValues : array of floating point numbers, that is filled by the function * with the offset correction applied for each of the temperature * included in the first argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ loadOffsetAvgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Records a weight offset thermal compensation table, in order to automatically correct the * measured weight based on the variation of temperature. * The weight correction will be applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, corresponding to temperature * variations for which an offset correction is specified. * @param compValues : array of floating point numbers, corresponding to the offset correction * to apply for each of the temperature variation included in the first * argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_offsetChgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Retrieves the weight offset thermal compensation table previously configured using the * set_offsetChgCompensationTable function. * The weight correction is applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, that is filled by the function * with all temperature variations for which an offset correction is specified. * @param compValues : array of floating point numbers, that is filled by the function * with the offset correction applied for each of the temperature * variation included in the first argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ loadOffsetChgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Records a weight span thermal compensation table, in order to automatically correct the * measured weight based on the compensation temperature. * The weight correction will be applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, corresponding to all averaged * temperatures for which a span correction is specified. * @param compValues : array of floating point numbers, corresponding to the span correction * (in percents) to apply for each of the temperature included in the first * argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_spanAvgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Retrieves the weight span thermal compensation table previously configured using the * set_spanAvgCompensationTable function. * The weight correction is applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, that is filled by the function * with all averaged temperatures for which an span correction is specified. * @param compValues : array of floating point numbers, that is filled by the function * with the span correction applied for each of the temperature * included in the first argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ loadSpanAvgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Records a weight span thermal compensation table, in order to automatically correct the * measured weight based on the variation of temperature. * The weight correction will be applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, corresponding to all variations of * temperatures for which a span correction is specified. * @param compValues : array of floating point numbers, corresponding to the span correction * (in percents) to apply for each of the temperature variation included * in the first argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_spanChgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Retrieves the weight span thermal compensation table previously configured using the * set_spanChgCompensationTable function. * The weight correction is applied by linear interpolation between specified points. * * @param tempValues : array of floating point numbers, that is filled by the function * with all variation of temperature for which an span correction is specified. * @param compValues : array of floating point numbers, that is filled by the function * with the span correction applied for each of variation of temperature * included in the first argument, index by index. * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ loadSpanChgCompensationTable(tempValues: number[], compValues: number[]): Promise<number>; /** * Continues the enumeration of weighing scale sensors started using yFirstWeighScale(). * Caution: You can't make any assumption about the returned weighing scale sensors order. * If you want to find a specific a weighing scale sensor, use WeighScale.findWeighScale() * and a hardwareID or a logical name. * * @return a pointer to a YWeighScale object, corresponding to * a weighing scale sensor currently online, or a null pointer * if there are no more weighing scale sensors to enumerate. */ nextWeighScale(): YWeighScale | null; /** * Starts the enumeration of weighing scale sensors currently accessible. * Use the method YWeighScale.nextWeighScale() to iterate on * next weighing scale sensors. * * @return a pointer to a YWeighScale object, corresponding to * the first weighing scale sensor currently online, or a null pointer * if there are none. */ static FirstWeighScale(): YWeighScale | null; /** * Starts the enumeration of weighing scale sensors currently accessible. * Use the method YWeighScale.nextWeighScale() to iterate on * next weighing scale sensors. * * @param yctx : a YAPI context. * * @return a pointer to a YWeighScale object, corresponding to * the first weighing scale sensor currently online, or a null pointer * if there are none. */ static FirstWeighScaleInContext(yctx: YAPIContext): YWeighScale | null; } export declare namespace YWeighScale { const enum EXCITATION { OFF = 0, DC = 1, AC = 2, INVALID = -1 } interface ValueCallback { (func: YWeighScale, value: string): void; } interface TimedReportCallback { (func: YWeighScale, measure: YMeasure): void; } }