/********************************************************************* * * $Id: svn_id $ * * Implements the high-level API for ColorSensor 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, YFunction } from './yocto_api.js'; /** * YColorSensor Class: color sensor control interface * * The YColorSensor class allows you to read and configure Yoctopuce color sensors. */ export declare class YColorSensor extends YFunction { _className: string; _estimationModel: YColorSensor.ESTIMATIONMODEL; _workingMode: YColorSensor.WORKINGMODE; _ledCurrent: number; _ledCalibration: number; _integrationTime: number; _gain: number; _saturation: number; _estimatedRGB: number; _estimatedHSL: number; _estimatedXYZ: string; _estimatedOkLab: string; _nearRAL1: string; _nearRAL2: string; _nearRAL3: string; _nearHTMLColor: string; _nearSimpleColorIndex: YColorSensor.NEARSIMPLECOLORINDEX; _nearSimpleColor: string; _valueCallbackColorSensor: YColorSensor.ValueCallback | null; readonly ESTIMATIONMODEL_REFLECTION: YColorSensor.ESTIMATIONMODEL; readonly ESTIMATIONMODEL_EMISSION: YColorSensor.ESTIMATIONMODEL; readonly ESTIMATIONMODEL_INVALID: YColorSensor.ESTIMATIONMODEL; readonly WORKINGMODE_AUTO: YColorSensor.WORKINGMODE; readonly WORKINGMODE_EXPERT: YColorSensor.WORKINGMODE; readonly WORKINGMODE_INVALID: YColorSensor.WORKINGMODE; readonly LEDCURRENT_INVALID: number; readonly LEDCALIBRATION_INVALID: number; readonly INTEGRATIONTIME_INVALID: number; readonly GAIN_INVALID: number; readonly SATURATION_INVALID: number; readonly ESTIMATEDRGB_INVALID: number; readonly ESTIMATEDHSL_INVALID: number; readonly ESTIMATEDXYZ_INVALID: string; readonly ESTIMATEDOKLAB_INVALID: string; readonly NEARRAL1_INVALID: string; readonly NEARRAL2_INVALID: string; readonly NEARRAL3_INVALID: string; readonly NEARHTMLCOLOR_INVALID: string; readonly NEARSIMPLECOLORINDEX_BROWN: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_RED: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_ORANGE: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_YELLOW: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_WHITE: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_GRAY: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_BLACK: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_GREEN: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_BLUE: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_PURPLE: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_PINK: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLORINDEX_INVALID: YColorSensor.NEARSIMPLECOLORINDEX; readonly NEARSIMPLECOLOR_INVALID: string; static readonly ESTIMATIONMODEL_REFLECTION: YColorSensor.ESTIMATIONMODEL; static readonly ESTIMATIONMODEL_EMISSION: YColorSensor.ESTIMATIONMODEL; static readonly ESTIMATIONMODEL_INVALID: YColorSensor.ESTIMATIONMODEL; static readonly WORKINGMODE_AUTO: YColorSensor.WORKINGMODE; static readonly WORKINGMODE_EXPERT: YColorSensor.WORKINGMODE; static readonly WORKINGMODE_INVALID: YColorSensor.WORKINGMODE; static readonly LEDCURRENT_INVALID: number; static readonly LEDCALIBRATION_INVALID: number; static readonly INTEGRATIONTIME_INVALID: number; static readonly GAIN_INVALID: number; static readonly SATURATION_INVALID: number; static readonly ESTIMATEDRGB_INVALID: number; static readonly ESTIMATEDHSL_INVALID: number; static readonly ESTIMATEDXYZ_INVALID: string; static readonly ESTIMATEDOKLAB_INVALID: string; static readonly NEARRAL1_INVALID: string; static readonly NEARRAL2_INVALID: string; static readonly NEARRAL3_INVALID: string; static readonly NEARHTMLCOLOR_INVALID: string; static readonly NEARSIMPLECOLORINDEX_BROWN: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_RED: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_ORANGE: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_YELLOW: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_WHITE: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_GRAY: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_BLACK: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_GREEN: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_BLUE: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_PURPLE: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_PINK: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLORINDEX_INVALID: YColorSensor.NEARSIMPLECOLORINDEX; static readonly NEARSIMPLECOLOR_INVALID: string; constructor(yapi: YAPIContext, func: string); imm_parseAttr(name: string, val: any): number; /** * Returns the predictive model used for color estimation (reflective or emissive). * * @return either YColorSensor.ESTIMATIONMODEL_REFLECTION or YColorSensor.ESTIMATIONMODEL_EMISSION, * according to the predictive model used for color estimation (reflective or emissive) * * On failure, throws an exception or returns YColorSensor.ESTIMATIONMODEL_INVALID. */ get_estimationModel(): Promise; /** * Changes the predictive model to be used for color estimation (reflective or emissive). * Remember to call the saveToFlash() method of the module if the modification must be kept. * * @param newval : either YColorSensor.ESTIMATIONMODEL_REFLECTION or * YColorSensor.ESTIMATIONMODEL_EMISSION, according to the predictive model to be used for color * estimation (reflective or emissive) * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_estimationModel(newval: YColorSensor.ESTIMATIONMODEL): Promise; /** * Returns the sensor working mode. * In Auto mode, sensor parameters are automatically set based on the selected estimation model. * In Expert mode, sensor parameters such as gain and integration time are configured manually. * * @return either YColorSensor.WORKINGMODE_AUTO or YColorSensor.WORKINGMODE_EXPERT, according to the * sensor working mode * * On failure, throws an exception or returns YColorSensor.WORKINGMODE_INVALID. */ get_workingMode(): Promise; /** * Changes the sensor working mode. * In Auto mode, sensor parameters are automatically set based on the selected estimation model. * In Expert mode, sensor parameters such as gain and integration time are configured manually. * Remember to call the saveToFlash() method of the module if the modification must be kept. * * @param newval : either YColorSensor.WORKINGMODE_AUTO or YColorSensor.WORKINGMODE_EXPERT, according * to the sensor working mode * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_workingMode(newval: YColorSensor.WORKINGMODE): Promise; /** * Returns the amount of current sent to the illumination LEDs, for reflection measures. * The value is an integer ranging from 0 (LEDs off) to 254 (LEDs at maximum intensity). * * @return an integer corresponding to the amount of current sent to the illumination LEDs, for reflection measures * * On failure, throws an exception or returns YColorSensor.LEDCURRENT_INVALID. */ get_ledCurrent(): Promise; /** * Changes the amount of current sent to the illumination LEDs, for reflection measures. * The value is an integer ranging from 0 (LEDs off) to 254 (LEDs at maximum intensity). * * @param newval : an integer corresponding to the amount of current sent to the illumination LEDs, * for reflection measures * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_ledCurrent(newval: number): Promise; /** * Returns the current sent to the illumination LEDs during the latest calibration. * * @return an integer corresponding to the current sent to the illumination LEDs during the latest calibration * * On failure, throws an exception or returns YColorSensor.LEDCALIBRATION_INVALID. */ get_ledCalibration(): Promise; /** * Remember the LED current sent to the illumination LEDs during a calibration. * Thanks to this, the device is able to use the same current when taking measures. * Remember to call the saveToFlash() method of the module if the modification must be kept. * * @param newval : an integer * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_ledCalibration(newval: number): Promise; /** * Returns the current integration time for spectral measure, in milliseconds. * A longer integration time increase the sensitivity for low light conditions, * but reduces the measure taking rate and may lead to saturation for lighter colors. * * @return an integer corresponding to the current integration time for spectral measure, in milliseconds * * On failure, throws an exception or returns YColorSensor.INTEGRATIONTIME_INVALID. */ get_integrationTime(): Promise; /** * Changes the integration time for spectral measure, in milliseconds. * A longer integration time increase the sensitivity for low light conditions, * but reduces the measure taking rate and may lead to saturation for lighter colors. * This method can only be used when the sensor is configured in expert mode; * when running in auto mode, the change is ignored. * Remember to call the saveToFlash() method of the module if the modification must be kept. * * @param newval : an integer corresponding to the integration time for spectral measure, in milliseconds * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_integrationTime(newval: number): Promise; /** * Returns the current spectral channel detector gain exponent. * For a value n ranging from 0 to 12, the applied gain is 2^(n-1). * 0 corresponds to a gain of 0.5, and 12 corresponds to a gain of 2048. * * @return an integer corresponding to the current spectral channel detector gain exponent * * On failure, throws an exception or returns YColorSensor.GAIN_INVALID. */ get_gain(): Promise; /** * Changes the spectral channel detector gain exponent. * For a value n ranging from 0 to 12, the applied gain is 2^(n-1). * 0 corresponds to a gain of 0.5, and 12 corresponds to a gain of 2048. * This method can only be used when the sensor is configured in expert mode; * when running in auto mode, the change is ignored. * Remember to call the saveToFlash() method of the module if the modification must be kept. * * @param newval : an integer corresponding to the spectral channel detector gain exponent * * @return YAPI.SUCCESS if the call succeeds. * * On failure, throws an exception or returns a negative error code. */ set_gain(newval: number): Promise; /** * Returns the current saturation state of the sensor, as an integer. * Bit 0 indicates saturation of the analog sensor, which can only * be corrected by reducing the gain parameters or the luminosity. * Bit 1 indicates saturation of the digital interface, which can * be corrected by reducing the integration time or the gain. * * @return an integer corresponding to the current saturation state of the sensor, as an integer * * On failure, throws an exception or returns YColorSensor.SATURATION_INVALID. */ get_saturation(): Promise; /** * Returns the estimated color in RGB color model (0xRRGGBB). * The RGB color model describes each color using a combination of 3 components: * - Red (R): the intensity of red, in the 0...255 range * - Green (G): the intensity of green, in the 0...255 range * - Blue (B): the intensity of blue, in the 0...255 range * * @return an integer corresponding to the estimated color in RGB color model (0xRRGGBB) * * On failure, throws an exception or returns YColorSensor.ESTIMATEDRGB_INVALID. */ get_estimatedRGB(): Promise; /** * Returns the estimated color in HSL color model (0xHHSSLL). * The HSL color model describes each color using a combination of 3 components: * - Hue (H): the angle on the color wheel (0-360 degrees), mapped to 0...255 * - Saturation (S): the intensity of the color (0-100%), mapped to 0...255 * - Lightness (L): the brightness of the color (0-100%), mapped to 0...255 * * @return an integer corresponding to the estimated color in HSL color model (0xHHSSLL) * * On failure, throws an exception or returns YColorSensor.ESTIMATEDHSL_INVALID. */ get_estimatedHSL(): Promise; /** * Returns the estimated color according to the CIE XYZ color model. * This color model is based on human vision and light perception, with three components * represented by real numbers between 0 and 1: * - X: corresponds to a component mixing sensitivity to red and green * - Y: represents luminance (perceived brightness) * - Z: corresponds to sensitivity to blue * * @return a string corresponding to the estimated color according to the CIE XYZ color model * * On failure, throws an exception or returns YColorSensor.ESTIMATEDXYZ_INVALID. */ get_estimatedXYZ(): Promise; /** * Returns the estimated color according to the OkLab color model. * OkLab is a perceptual color model that aims to align human color perception with numerical * values, so that colors that are visually near are also numerically near. Colors are represented * using three components: * - L: lightness, a real number between 0 and 1 * - a: color variations between green and red, between -0.5 and 0.5 * - b: color variations between blue and yellow, between -0.5 and 0.5. * * @return a string corresponding to the estimated color according to the OkLab color model * * On failure, throws an exception or returns YColorSensor.ESTIMATEDOKLAB_INVALID. */ get_estimatedOkLab(): Promise; /** * Returns the RAL Classic color closest to the estimated color, with a similarity ratio. * * @return a string corresponding to the RAL Classic color closest to the estimated color, with a similarity ratio * * On failure, throws an exception or returns YColorSensor.NEARRAL1_INVALID. */ get_nearRAL1(): Promise; /** * Returns the second closest RAL Classic color to the estimated color, with a similarity ratio. * * @return a string corresponding to the second closest RAL Classic color to the estimated color, with * a similarity ratio * * On failure, throws an exception or returns YColorSensor.NEARRAL2_INVALID. */ get_nearRAL2(): Promise; /** * Returns the third closest RAL Classic color to the estimated color, with a similarity ratio. * * @return a string corresponding to the third closest RAL Classic color to the estimated color, with * a similarity ratio * * On failure, throws an exception or returns YColorSensor.NEARRAL3_INVALID. */ get_nearRAL3(): Promise; /** * Returns the name of the HTML color closest to the estimated color. * * @return a string corresponding to the name of the HTML color closest to the estimated color * * On failure, throws an exception or returns YColorSensor.NEARHTMLCOLOR_INVALID. */ get_nearHTMLColor(): Promise; /** * Returns the index of the basic color typically used to refer to the estimated color (enumerated value). * The list of basic colors recognized is: * - 0 - Brown * - 1 - Red * - 2 - Orange * - 3 - Yellow * - 4 - White * - 5 - Gray * - 6 - Black * - 7 - Green * - 8 - Blue * - 9 - Purple * - 10 - Pink * * @return a value among YColorSensor.NEARSIMPLECOLORINDEX_BROWN, * YColorSensor.NEARSIMPLECOLORINDEX_RED, YColorSensor.NEARSIMPLECOLORINDEX_ORANGE, * YColorSensor.NEARSIMPLECOLORINDEX_YELLOW, YColorSensor.NEARSIMPLECOLORINDEX_WHITE, * YColorSensor.NEARSIMPLECOLORINDEX_GRAY, YColorSensor.NEARSIMPLECOLORINDEX_BLACK, * YColorSensor.NEARSIMPLECOLORINDEX_GREEN, YColorSensor.NEARSIMPLECOLORINDEX_BLUE, * YColorSensor.NEARSIMPLECOLORINDEX_PURPLE and YColorSensor.NEARSIMPLECOLORINDEX_PINK corresponding * to the index of the basic color typically used to refer to the estimated color (enumerated value) * * On failure, throws an exception or returns YColorSensor.NEARSIMPLECOLORINDEX_INVALID. */ get_nearSimpleColorIndex(): Promise; /** * Returns the name of the basic color typically used to refer to the estimated color. * * @return a string corresponding to the name of the basic color typically used to refer to the estimated color * * On failure, throws an exception or returns YColorSensor.NEARSIMPLECOLOR_INVALID. */ get_nearSimpleColor(): Promise; /** * Retrieves a color 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 color sensor is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YColorSensor.isOnline() to test if the color sensor is * indeed online at a given time. In case of ambiguity when looking for * a color 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 color sensor, for instance * MyDevice.colorSensor. * * @return a YColorSensor object allowing you to drive the color sensor. */ static FindColorSensor(func: string): YColorSensor; /** * Retrieves a color 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 color sensor is online at the time * it is invoked. The returned object is nevertheless valid. * Use the method YColorSensor.isOnline() to test if the color sensor is * indeed online at a given time. In case of ambiguity when looking for * a color 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 color sensor, for instance * MyDevice.colorSensor. * * @return a YColorSensor object allowing you to drive the color sensor. */ static FindColorSensorInContext(yctx: YAPIContext, func: string): YColorSensor; /** * 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: YColorSensor.ValueCallback | null): Promise; _invokeValueCallback(value: string): Promise; /** * Turns on the built-in illumination LEDs using the same current as used during the latest calibration. * On failure, throws an exception or returns a negative error code. */ turnLedOn(): Promise; /** * Turns off the built-in illumination LEDs. * On failure, throws an exception or returns a negative error code. */ turnLedOff(): Promise; /** * Continues the enumeration of color sensors started using yFirstColorSensor(). * Caution: You can't make any assumption about the returned color sensors order. * If you want to find a specific a color sensor, use ColorSensor.findColorSensor() * and a hardwareID or a logical name. * * @return a pointer to a YColorSensor object, corresponding to * a color sensor currently online, or a null pointer * if there are no more color sensors to enumerate. */ nextColorSensor(): YColorSensor | null; /** * Starts the enumeration of color sensors currently accessible. * Use the method YColorSensor.nextColorSensor() to iterate on * next color sensors. * * @return a pointer to a YColorSensor object, corresponding to * the first color sensor currently online, or a null pointer * if there are none. */ static FirstColorSensor(): YColorSensor | null; /** * Starts the enumeration of color sensors currently accessible. * Use the method YColorSensor.nextColorSensor() to iterate on * next color sensors. * * @param yctx : a YAPI context. * * @return a pointer to a YColorSensor object, corresponding to * the first color sensor currently online, or a null pointer * if there are none. */ static FirstColorSensorInContext(yctx: YAPIContext): YColorSensor | null; } export declare namespace YColorSensor { const enum ESTIMATIONMODEL { REFLECTION = 0, EMISSION = 1, INVALID = -1 } const enum WORKINGMODE { AUTO = 0, EXPERT = 1, INVALID = -1 } const enum NEARSIMPLECOLORINDEX { BROWN = 0, RED = 1, ORANGE = 2, YELLOW = 3, WHITE = 4, GRAY = 5, BLACK = 6, GREEN = 7, BLUE = 8, PURPLE = 9, PINK = 10, INVALID = -1 } interface ValueCallback { (func: YColorSensor, value: string): void; } }