Homec4science
Diffusion servicenow-chat-alert (master) Browse

servicenow-chat-alert/yoctoLib.python.26380/Sources/yocto_colorledcluster.py
9f2fba144c8fmaster

Last Change
Raw File

yocto_colorledcluster.py
View Options

#*********************************************************************
#*
#* $Id: yocto_colorledcluster.py 24939 2016-07-01 08:45:11Z seb $
#*
#* Implements yFindColorLedCluster(), the high-level API for ColorLedCluster 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.
#*
#*********************************************************************/
__docformat__ = 'restructuredtext en'
from yocto_api import *
#--- (YColorLedCluster class start)
#noinspection PyProtectedMember
class YColorLedCluster(YFunction):
"""
The Yoctopuce application programming interface
allows you to drive a color LED cluster. Unlike the ColorLed class, the ColorLedCluster
allows to handle several LEDs at one. Color changes can be done using RGB coordinates as well as
HSL coordinates.
The module performs all conversions form RGB to HSL automatically. It is then
self-evident to turn on a LED with a given hue and to progressively vary its
saturation or lightness. If needed, you can find more information on the
difference between RGB and HSL in the section following this one.
"""
#--- (end of YColorLedCluster class start)
#--- (YColorLedCluster return codes)
#--- (end of YColorLedCluster return codes)
#--- (YColorLedCluster dlldef)
#--- (end of YColorLedCluster dlldef)
#--- (YColorLedCluster definitions)
ACTIVELEDCOUNT_INVALID = YAPI.INVALID_UINT
MAXLEDCOUNT_INVALID = YAPI.INVALID_UINT
BLINKSEQMAXCOUNT_INVALID = YAPI.INVALID_UINT
BLINKSEQMAXSIZE_INVALID = YAPI.INVALID_UINT
COMMAND_INVALID = YAPI.INVALID_STRING
#--- (end of YColorLedCluster definitions)
def __init__(self, func):
super(YColorLedCluster, self).__init__(func)
self._className = 'ColorLedCluster'
#--- (YColorLedCluster attributes)
self._callback = None
self._activeLedCount = YColorLedCluster.ACTIVELEDCOUNT_INVALID
self._maxLedCount = YColorLedCluster.MAXLEDCOUNT_INVALID
self._blinkSeqMaxCount = YColorLedCluster.BLINKSEQMAXCOUNT_INVALID
self._blinkSeqMaxSize = YColorLedCluster.BLINKSEQMAXSIZE_INVALID
self._command = YColorLedCluster.COMMAND_INVALID
#--- (end of YColorLedCluster attributes)
#--- (YColorLedCluster implementation)
def _parseAttr(self, member):
if member.name == "activeLedCount":
self._activeLedCount = member.ivalue
return 1
if member.name == "maxLedCount":
self._maxLedCount = member.ivalue
return 1
if member.name == "blinkSeqMaxCount":
self._blinkSeqMaxCount = member.ivalue
return 1
if member.name == "blinkSeqMaxSize":
self._blinkSeqMaxSize = member.ivalue
return 1
if member.name == "command":
self._command = member.svalue
return 1
super(YColorLedCluster, self)._parseAttr(member)
def get_activeLedCount(self):
"""
Returns the number of LEDs currently handled by the device.
@return an integer corresponding to the number of LEDs currently handled by the device
On failure, throws an exception or returns YColorLedCluster.ACTIVELEDCOUNT_INVALID.
"""
if self._cacheExpiration <= YAPI.GetTickCount():
if self.load(YAPI.DefaultCacheValidity) != YAPI.SUCCESS:
return YColorLedCluster.ACTIVELEDCOUNT_INVALID
return self._activeLedCount
def set_activeLedCount(self, newval):
"""
Changes the number of LEDs currently handled by the device.
@param newval : an integer corresponding to the number of LEDs currently handled by the device
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
rest_val = str(newval)
return self._setAttr("activeLedCount", rest_val)
def get_maxLedCount(self):
"""
Returns the maximum number of LEDs that the device can handle.
@return an integer corresponding to the maximum number of LEDs that the device can handle
On failure, throws an exception or returns YColorLedCluster.MAXLEDCOUNT_INVALID.
"""
if self._cacheExpiration == datetime.datetime.fromtimestamp(0):
if self.load(YAPI.DefaultCacheValidity) != YAPI.SUCCESS:
return YColorLedCluster.MAXLEDCOUNT_INVALID
return self._maxLedCount
def get_blinkSeqMaxCount(self):
"""
Returns the maximum number of sequences that the device can handle.
@return an integer corresponding to the maximum number of sequences that the device can handle
On failure, throws an exception or returns YColorLedCluster.BLINKSEQMAXCOUNT_INVALID.
"""
if self._cacheExpiration == datetime.datetime.fromtimestamp(0):
if self.load(YAPI.DefaultCacheValidity) != YAPI.SUCCESS:
return YColorLedCluster.BLINKSEQMAXCOUNT_INVALID
return self._blinkSeqMaxCount
def get_blinkSeqMaxSize(self):
"""
Returns the maximum length of sequences.
@return an integer corresponding to the maximum length of sequences
On failure, throws an exception or returns YColorLedCluster.BLINKSEQMAXSIZE_INVALID.
"""
if self._cacheExpiration == datetime.datetime.fromtimestamp(0):
if self.load(YAPI.DefaultCacheValidity) != YAPI.SUCCESS:
return YColorLedCluster.BLINKSEQMAXSIZE_INVALID
return self._blinkSeqMaxSize
def get_command(self):
if self._cacheExpiration <= YAPI.GetTickCount():
if self.load(YAPI.DefaultCacheValidity) != YAPI.SUCCESS:
return YColorLedCluster.COMMAND_INVALID
return self._command
def set_command(self, newval):
rest_val = newval
return self._setAttr("command", rest_val)
@staticmethod
def FindColorLedCluster(func):
"""
Retrieves a RGB LED cluster for a given identifier.
The identifier can be specified using several formats:
<ul>
<li>FunctionLogicalName</li>
<li>ModuleSerialNumber.FunctionIdentifier</li>
<li>ModuleSerialNumber.FunctionLogicalName</li>
<li>ModuleLogicalName.FunctionIdentifier</li>
<li>ModuleLogicalName.FunctionLogicalName</li>
</ul>
This function does not require that the RGB LED cluster is online at the time
it is invoked. The returned object is nevertheless valid.
Use the method YColorLedCluster.isOnline() to test if the RGB LED cluster is
indeed online at a given time. In case of ambiguity when looking for
a RGB LED cluster 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 func : a string that uniquely characterizes the RGB LED cluster
@return a YColorLedCluster object allowing you to drive the RGB LED cluster.
"""
# obj
obj = YFunction._FindFromCache("ColorLedCluster", func)
if obj is None:
obj = YColorLedCluster(func)
YFunction._AddToCache("ColorLedCluster", func, obj)
return obj
def sendCommand(self, command):
# //may throw an exception
return self.set_command(command)
def set_rgbColor(self, ledIndex, count, rgbValue):
"""
Changes the current color of consecutve LEDs in the cluster, using a RGB color. Encoding is done as
follows: 0xRRGGBB.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param rgbValue : new color.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("SR" + str(int(ledIndex)) + "," + str(int(count)) + "," + ("%X" % rgbValue))
def set_rgbColorAtPowerOn(self, ledIndex, count, rgbValue):
"""
Changes the color at device startup of consecutve LEDs in the cluster, using a RGB color. Encoding
is done as follows: 0xRRGGBB.
Don't forget to call saveLedsConfigAtPowerOn() to make sure the modification is saved in the device
flash memory.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param rgbValue : new color.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("SC" + str(int(ledIndex)) + "," + str(int(count)) + "," + ("%X" % rgbValue))
def set_hslColor(self, ledIndex, count, hslValue):
"""
Changes the current color of consecutive LEDs in the cluster, using a HSL color. Encoding is done
as follows: 0xHHSSLL.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param hslValue : new color.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("SH" + str(int(ledIndex)) + "," + str(int(count)) + "," + ("%X" % hslValue))
def rgb_move(self, ledIndex, count, rgbValue, delay):
"""
Allows you to modify the current color of a group of adjacent LEDs to another color, in a seamless and
autonomous manner. The transition is performed in the RGB space.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param rgbValue : new color (0xRRGGBB).
@param delay : transition duration in ms
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("MR" + str(int(ledIndex)) + "," + str(int(count)) + "," + ("%X" % rgbValue) + "," + str(int(delay)))
def hsl_move(self, ledIndex, count, hslValue, delay):
"""
Allows you to modify the current color of a group of adjacent LEDs to another color, in a seamless and
autonomous manner. The transition is performed in the HSL space. In HSL, hue is a circular
value (0..360°). There are always two paths to perform the transition: by increasing
or by decreasing the hue. The module selects the shortest transition.
If the difference is exactly 180°, the module selects the transition which increases
the hue.
@param ledIndex : index of the fisrt affected LED.
@param count : affected LED count.
@param hslValue : new color (0xHHSSLL).
@param delay : transition duration in ms
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("MH" + str(int(ledIndex)) + "," + str(int(count)) + "," + ("%X" % hslValue) + "," + str(int(delay)))
def addRgbMoveToBlinkSeq(self, seqIndex, rgbValue, delay):
"""
Adds an RGB transition to a sequence. A sequence is a transition list, which can
be executed in loop by a group of LEDs. Sequences are persistent and are saved
in the device flash memory as soon as the saveBlinkSeq() method is called.
@param seqIndex : sequence index.
@param rgbValue : target color (0xRRGGBB)
@param delay : transition duration in ms
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("AR" + str(int(seqIndex)) + "," + ("%X" % rgbValue) + "," + str(int(delay)))
def addHslMoveToBlinkSeq(self, seqIndex, hslValue, delay):
"""
Adds an HSL transition to a sequence. A sequence is a transition list, which can
be executed in loop by an group of LEDs. Sequences are persistant and are saved
in the device flash memory as soon as the saveBlinkSeq() method is called.
@param seqIndex : sequence index.
@param hslValue : target color (0xHHSSLL)
@param delay : transition duration in ms
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("AH" + str(int(seqIndex)) + "," + ("%X" % hslValue) + "," + str(int(delay)))
def addMirrorToBlinkSeq(self, seqIndex):
"""
Adds a mirror ending to a sequence. When the sequence will reach the end of the last
transition, its running speed will automatically be reversed so that the sequence plays
in the reverse direction, like in a mirror. After the first transition of the sequence
is played at the end of the reverse execution, the sequence starts again in
the initial direction.
@param seqIndex : sequence index.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("AC" + str(int(seqIndex)) + ",0,0")
def linkLedToBlinkSeq(self, ledIndex, count, seqIndex, offset):
"""
Links adjacent LEDs to a specific sequence. These LEDs start to execute
the sequence as soon as startBlinkSeq is called. It is possible to add an offset
in the execution: that way we can have several groups of LED executing the same
sequence, with a temporal offset. A LED cannot be linked to more than one sequence.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param seqIndex : sequence index.
@param offset : execution offset in ms.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("LS" + str(int(ledIndex)) + "," + str(int(count)) + "," + str(int(seqIndex)) + "," + str(int(offset)))
def linkLedToBlinkSeqAtPowerOn(self, ledIndex, count, seqIndex, offset):
"""
Links adjacent LEDs to a specific sequence at device poweron. Don't forget to configure
the sequence auto start flag as well and call saveLedsConfigAtPowerOn(). It is possible to add an offset
in the execution: that way we can have several groups of LEDs executing the same
sequence, with a temporal offset. A LED cannot be linked to more than one sequence.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param seqIndex : sequence index.
@param offset : execution offset in ms.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("LO" + str(int(ledIndex)) + "," + str(int(count)) + "," + str(int(seqIndex)) + "," + str(int(offset)))
def linkLedToPeriodicBlinkSeq(self, ledIndex, count, seqIndex, periods):
"""
Links adjacent LEDs to a specific sequence. These LED start to execute
the sequence as soon as startBlinkSeq is called. This function automatically
introduces a shift between LEDs so that the specified number of sequence periods
appears on the group of LEDs (wave effect).
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@param seqIndex : sequence index.
@param periods : number of periods to show on LEDs.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("LP" + str(int(ledIndex)) + "," + str(int(count)) + "," + str(int(seqIndex)) + "," + str(int(periods)))
def unlinkLedFromBlinkSeq(self, ledIndex, count):
"""
Unlinks adjacent LEDs from a sequence.
@param ledIndex : index of the first affected LED.
@param count : affected LED count.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("US" + str(int(ledIndex)) + "," + str(int(count)))
def startBlinkSeq(self, seqIndex):
"""
Starts a sequence execution: every LED linked to that sequence starts to
run it in a loop.
@param seqIndex : index of the sequence to start.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("SS" + str(int(seqIndex)))
def stopBlinkSeq(self, seqIndex):
"""
Stops a sequence execution. If started again, the execution
restarts from the beginning.
@param seqIndex : index of the sequence to stop.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("XS" + str(int(seqIndex)))
def resetBlinkSeq(self, seqIndex):
"""
Stops a sequence execution and resets its contents. Leds linked to this
sequence are not automatically updated anymore.
@param seqIndex : index of the sequence to reset
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("ZS" + str(int(seqIndex)))
def set_blinkSeqStateAtPowerOn(self, seqIndex, autostart):
"""
Configures a sequence to make it start automatically at device
startup. Don't forget to call saveBlinkSeq() to make sure the
modification is saved in the device flash memory.
@param seqIndex : index of the sequence to reset.
@param autostart : 0 to keep the sequence turned off and 1 to start it automatically.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("AS" + str(int(seqIndex)) + "," + str(int(autostart)))
def set_blinkSeqSpeed(self, seqIndex, speed):
"""
Changes the execution speed of a sequence. The natural execution speed is 1000 per
thousand. If you configure a slower speed, you can play the sequence in slow-motion.
If you set a negative speed, you can play the sequence in reverse direction.
@param seqIndex : index of the sequence to start.
@param speed : sequence running speed (-1000...1000).
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("CS" + str(int(seqIndex)) + "," + str(int(speed)))
def saveLedsConfigAtPowerOn(self):
"""
Saves the LEDs power-on configuration. This includes the start-up color or
sequence binding for all LEDs. Warning: if some LEDs are linked to a sequence, the
method saveBlinkSeq() must also be called to save the sequence definition.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("WL")
def saveLedsState(self):
# // may throw an exception
return self.sendCommand("WL")
def saveBlinkSeq(self, seqIndex):
"""
Saves the definition of a sequence. Warning: only sequence steps and flags are saved.
to save the LEDs startup bindings, the method saveLedsConfigAtPowerOn()
must be called.
@param seqIndex : index of the sequence to start.
@return YAPI.SUCCESS when the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
return self.sendCommand("WS" + str(int(seqIndex)))
def set_rgbColorBuffer(self, ledIndex, buff):
"""
Sends a binary buffer to the LED RGB buffer, as is.
First three bytes are RGB components for LED specified as parameter, the
next three bytes for the next LED, etc.
@param ledIndex : index of the first LED which should be updated
@param buff : the binary buffer to send
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
# // may throw an exception
return self._upload("rgb:0:" + str(int(ledIndex)), buff)
def set_rgbColorArray(self, ledIndex, rgbList):
"""
Sends 24bit RGB colors (provided as a list of integers) to the LED RGB buffer, as is.
The first number represents the RGB value of the LED specified as parameter, the second
number represents the RGB value of the next LED, etc.
@param ledIndex : index of the first LED which should be updated
@param rgbList : a list of 24bit RGB codes, in the form 0xRRGGBB
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
# listlen
# buff
# idx
# rgb
# res
listlen = len(rgbList)
buff = bytearray(3*listlen)
idx = 0
while idx < listlen:
rgb = rgbList[idx]
buff[3*idx] = ((((rgb) >> (16))) & (255))
buff[3*idx+1] = ((((rgb) >> (8))) & (255))
buff[3*idx+2] = ((rgb) & (255))
idx = idx + 1
# // may throw an exception
res = self._upload("rgb:0:" + str(int(ledIndex)), buff)
return res
def rgbArray_move(self, rgbList, delay):
"""
Sets up a smooth RGB color transition to the specified pixel-by-pixel list of RGB
color codes. The first color code represents the target RGB value of the first LED,
the next color code represents the target value of the next LED, etc.
@param rgbList : a list of target 24bit RGB codes, in the form 0xRRGGBB
@param delay : transition duration in ms
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
# listlen
# buff
# idx
# rgb
# res
listlen = len(rgbList)
buff = bytearray(3*listlen)
idx = 0
while idx < listlen:
rgb = rgbList[idx]
buff[3*idx] = ((((rgb) >> (16))) & (255))
buff[3*idx+1] = ((((rgb) >> (8))) & (255))
buff[3*idx+2] = ((rgb) & (255))
idx = idx + 1
# // may throw an exception
res = self._upload("rgb:" + str(int(delay)), buff)
return res
def set_hslColorBuffer(self, ledIndex, buff):
"""
Sends a binary buffer to the LED HSL buffer, as is.
First three bytes are HSL components for the LED specified as parameter, the
next three bytes for the second LED, etc.
@param ledIndex : index of the first LED which should be updated
@param buff : the binary buffer to send
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
# // may throw an exception
return self._upload("hsl:0:" + str(int(ledIndex)), buff)
def set_hslColorArray(self, ledIndex, hslList):
"""
Sends 24bit HSL colors (provided as a list of integers) to the LED HSL buffer, as is.
The first number represents the HSL value of the LED specified as parameter, the second number represents
the HSL value of the second LED, etc.
@param ledIndex : index of the first LED which should be updated
@param hslList : a list of 24bit HSL codes, in the form 0xHHSSLL
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
# listlen
# buff
# idx
# hsl
# res
listlen = len(hslList)
buff = bytearray(3*listlen)
idx = 0
while idx < listlen:
hsl = hslList[idx]
buff[3*idx] = ((((hsl) >> (16))) & (255))
buff[3*idx+1] = ((((hsl) >> (8))) & (255))
buff[3*idx+2] = ((hsl) & (255))
idx = idx + 1
# // may throw an exception
res = self._upload("hsl:0:" + str(int(ledIndex)), buff)
return res
def hslArray_move(self, hslList, delay):
"""
Sets up a smooth HSL color transition to the specified pixel-by-pixel list of HSL
color codes. The first color code represents the target HSL value of the first LED,
the second color code represents the target value of the second LED, etc.
@param hslList : a list of target 24bit HSL codes, in the form 0xHHSSLL
@param delay : transition duration in ms
@return YAPI.SUCCESS if the call succeeds.
On failure, throws an exception or returns a negative error code.
"""
# listlen
# buff
# idx
# hsl
# res
listlen = len(hslList)
buff = bytearray(3*listlen)
idx = 0
while idx < listlen:
hsl = hslList[idx]
buff[3*idx] = ((((hsl) >> (16))) & (255))
buff[3*idx+1] = ((((hsl) >> (8))) & (255))
buff[3*idx+2] = ((hsl) & (255))
idx = idx + 1
# // may throw an exception
res = self._upload("hsl:" + str(int(delay)), buff)
return res
def get_rgbColorBuffer(self, ledIndex, count):
"""
Returns a binary buffer with content from the LED RGB buffer, as is.
First three bytes are RGB components for the first LED in the interval,
the next three bytes for the second LED in the interval, etc.
@param ledIndex : index of the first LED which should be returned
@param count : number of LEDs which should be returned
@return a binary buffer with RGB components of selected LEDs.
On failure, throws an exception or returns an empty binary buffer.
"""
# // may throw an exception
return self._download("rgb.bin?typ=0&pos=" + str(int(3*ledIndex)) + "&len=" + str(int(3*count)))
def get_rgbColorArray(self, ledIndex, count):
"""
Returns a list on 24bit RGB color values with the current colors displayed on
the RGB leds. The first number represents the RGB value of the first LED,
the second number represents the RGB value of the second LED, etc.
@param ledIndex : index of the first LED which should be returned
@param count : number of LEDs which should be returned
@return a list of 24bit color codes with RGB components of selected LEDs, as 0xRRGGBB.
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# r
# g
# b
# // may throw an exception
buff = self._download("rgb.bin?typ=0&pos=" + str(int(3*ledIndex)) + "&len=" + str(int(3*count)))
del res[:]
idx = 0
while idx < count:
r = YGetByte(buff, 3*idx)
g = YGetByte(buff, 3*idx+1)
b = YGetByte(buff, 3*idx+2)
res.append(r*65536+g*256+b)
idx = idx + 1
return res
def get_rgbColorArrayAtPowerOn(self, ledIndex, count):
"""
Returns a list on 24bit RGB color values with the RGB LEDs startup colors.
The first number represents the startup RGB value of the first LED,
the second number represents the RGB value of the second LED, etc.
@param ledIndex : index of the first LED which should be returned
@param count : number of LEDs which should be returned
@return a list of 24bit color codes with RGB components of selected LEDs, as 0xRRGGBB.
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# r
# g
# b
# // may throw an exception
buff = self._download("rgb.bin?typ=4&pos=" + str(int(3*ledIndex)) + "&len=" + str(int(3*count)))
del res[:]
idx = 0
while idx < count:
r = YGetByte(buff, 3*idx)
g = YGetByte(buff, 3*idx+1)
b = YGetByte(buff, 3*idx+2)
res.append(r*65536+g*256+b)
idx = idx + 1
return res
def get_linkedSeqArray(self, ledIndex, count):
"""
Returns a list on sequence index for each RGB LED. The first number represents the
sequence index for the the first LED, the second number represents the sequence
index for the second LED, etc.
@param ledIndex : index of the first LED which should be returned
@param count : number of LEDs which should be returned
@return a list of integers with sequence index
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# seq
# // may throw an exception
buff = self._download("rgb.bin?typ=1&pos=" + str(int(ledIndex)) + "&len=" + str(int(count)))
del res[:]
idx = 0
while idx < count:
seq = YGetByte(buff, idx)
res.append(seq)
idx = idx + 1
return res
def get_blinkSeqSignatures(self, seqIndex, count):
"""
Returns a list on 32 bit signatures for specified blinking sequences.
Since blinking sequences cannot be read from the device, this can be used
to detect if a specific blinking sequence is already programmed.
@param seqIndex : index of the first blinking sequence which should be returned
@param count : number of blinking sequences which should be returned
@return a list of 32 bit integer signatures
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# hh
# hl
# lh
# ll
# // may throw an exception
buff = self._download("rgb.bin?typ=2&pos=" + str(int(4*seqIndex)) + "&len=" + str(int(4*count)))
del res[:]
idx = 0
while idx < count:
hh = YGetByte(buff, 4*idx)
hl = YGetByte(buff, 4*idx+1)
lh = YGetByte(buff, 4*idx+2)
ll = YGetByte(buff, 4*idx+3)
res.append(((hh) << (24))+((hl) << (16))+((lh) << (8))+ll)
idx = idx + 1
return res
def get_blinkSeqStateSpeed(self, seqIndex, count):
"""
Returns a list of integers with the current speed for specified blinking sequences.
@param seqIndex : index of the first sequence speed which should be returned
@param count : number of sequence speeds which should be returned
@return a list of integers, 0 for sequences turned off and 1 for sequences running
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# lh
# ll
# // may throw an exception
buff = self._download("rgb.bin?typ=6&pos=" + str(int(seqIndex)) + "&len=" + str(int(count)))
del res[:]
idx = 0
while idx < count:
lh = YGetByte(buff, 2*idx)
ll = YGetByte(buff, 2*idx+1)
res.append(((lh) << (8))+ll)
idx = idx + 1
return res
def get_blinkSeqStateAtPowerOn(self, seqIndex, count):
"""
Returns a list of integers with the "auto-start at power on" flag state for specified blinking sequences.
@param seqIndex : index of the first blinking sequence which should be returned
@param count : number of blinking sequences which should be returned
@return a list of integers, 0 for sequences turned off and 1 for sequences running
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# started
# // may throw an exception
buff = self._download("rgb.bin?typ=5&pos=" + str(int(seqIndex)) + "&len=" + str(int(count)))
del res[:]
idx = 0
while idx < count:
started = YGetByte(buff, idx)
res.append(started)
idx = idx + 1
return res
def get_blinkSeqState(self, seqIndex, count):
"""
Returns a list of integers with the started state for specified blinking sequences.
@param seqIndex : index of the first blinking sequence which should be returned
@param count : number of blinking sequences which should be returned
@return a list of integers, 0 for sequences turned off and 1 for sequences running
On failure, throws an exception or returns an empty array.
"""
# buff
res = []
# idx
# started
# // may throw an exception
buff = self._download("rgb.bin?typ=3&pos=" + str(int(seqIndex)) + "&len=" + str(int(count)))
del res[:]
idx = 0
while idx < count:
started = YGetByte(buff, idx)
res.append(started)
idx = idx + 1
return res
def nextColorLedCluster(self):
"""
Continues the enumeration of RGB LED clusters started using yFirstColorLedCluster().
@return a pointer to a YColorLedCluster object, corresponding to
a RGB LED cluster currently online, or a None pointer
if there are no more RGB LED clusters to enumerate.
"""
hwidRef = YRefParam()
if YAPI.YISERR(self._nextFunction(hwidRef)):
return None
if hwidRef.value == "":
return None
return YColorLedCluster.FindColorLedCluster(hwidRef.value)
#--- (end of YColorLedCluster implementation)
#--- (ColorLedCluster functions)
@staticmethod
def FirstColorLedCluster():
"""
Starts the enumeration of RGB LED clusters currently accessible.
Use the method YColorLedCluster.nextColorLedCluster() to iterate on
next RGB LED clusters.
@return a pointer to a YColorLedCluster object, corresponding to
the first RGB LED cluster currently online, or a None pointer
if there are none.
"""
devRef = YRefParam()
neededsizeRef = YRefParam()
serialRef = YRefParam()
funcIdRef = YRefParam()
funcNameRef = YRefParam()
funcValRef = YRefParam()
errmsgRef = YRefParam()
size = YAPI.C_INTSIZE
#noinspection PyTypeChecker,PyCallingNonCallable
p = (ctypes.c_int * 1)()
err = YAPI.apiGetFunctionsByClass("ColorLedCluster", 0, p, size, neededsizeRef, errmsgRef)
if YAPI.YISERR(err) or not neededsizeRef.value:
return None
if YAPI.YISERR(
YAPI.yapiGetFunctionInfo(p[0], devRef, serialRef, funcIdRef, funcNameRef, funcValRef, errmsgRef)):
return None
return YColorLedCluster.FindColorLedCluster(serialRef.value + "." + funcIdRef.value)
#--- (end of ColorLedCluster functions)
c4science · Help