Gecko [ lorencats.com ]

Name	Size	Permission	Action
__pycache__	[ DIR ]	drwxr-xr-x
__init__.py	10.73 KB	-rw-r--r--

Code Editor : init.py

import time
from sys import exit

try:
    import serial
    import serial.tools.list_ports
except ImportError:
    exit("This library requires the serial module\nInstall with: sudo pip install pyserial")

__version__ = '0.0.4'

VID = 0x16d0
PID = 0x08c4
NAME = 'Mote USB Dock'

MAX_PIXELS = 512
MAX_PIXELS_PER_CHANNEL = int(MAX_PIXELS / 4)

class Mote:
    """Represents a connected Mote device, communicating over USB serial.

The Mote class allows you to configure the 4 channels and set individual pixels.

It will attach to the first available Mote device unless `port_name` is specified at init.

:param port_name: Override auto-detect and specify an explicit port to use. Must be a complete path ie: /dev/tty.usbmodem1234 (default None)
    """

def __init__(self, port_name=None, white_point=(1.0, 1.0, 1.0)):
        self.port_name = port_name
        self._channel_count = 4
        self._channels = [None] * self._channel_count
        self._channel_flags = [0] * self._channel_count
        self._clear_on_exit = False

self.white_point = white_point

if self.port_name is None:
            self.port_name = self._find_serial_port(VID, PID, NAME)

if self.port_name is None:
                raise IOError("Unable to find Mote device")

self.port = serial.Serial(self.port_name, 115200, timeout=1)

def _find_serial_port(self, vid, pid, name):
        """Find a serial port by VID, PID and text name

:param vid: USB vendor ID to locate
        :param pid: USB product ID to locate
        :param name: USB device name to find where VID/PID match fails

"""

check_for = "USB VID:PID={vid:04x}:{pid:04x}".format(vid=vid,pid=pid).upper()
        ports = serial.tools.list_ports.comports()

for check_port in ports:
            if hasattr(serial.tools,'list_ports_common'):
                if (check_port.vid, check_port.pid) == (VID, PID):
                    return check_port.device
                continue

if check_for in check_port[2].upper() or name == check_port[1]:
                return check_port[0]

return None

def configure_channel(self, channel, num_pixels, gamma_correction=False):
        """Configure a channel

:param channel: Channel, either 1, 2, 3 or 4 corresponding to numbers on Mote
        :param num_pixels: Number of pixels to configure for this channel
        :param gamma_correction: Whether to enable gamma correction (default False)

"""

if channel > self._channel_count or channel < 1:
            raise ValueError("Channel index must be between 1 and {}".format(self._channel_count))
        if num_pixels > MAX_PIXELS_PER_CHANNEL:
            raise ValueError("Number of pixels can not be more than {max}".format(max=MAX_PIXELS_PER_CHANNEL))

self._channels[channel - 1] = [(0,0,0,1.0)] * num_pixels
        self._channel_flags[channel -1] = 1 if gamma_correction else 0

buf = bytearray()
        buf.append(channel)
        buf.append(num_pixels)
        buf.append(self._channel_flags[channel -1])

self.port.write(b'mote')
        self.port.write(b'c')
        self.port.write(buf)

def get_pixel_count(self, channel):
        """Get the number of pixels a channel is configured to use

:param channel: Channel, either 1, 2 3 or 4 corresponding to numbers on Mote

"""

if channel > self._channel_count or channel < 1:
            raise ValueError("Channel index must be between 1 and 4")
        if self._channels[channel-1] is None:
            raise ValueError("Channel {channel} has not been set up".format(channel=channel))

return len(self._channels[channel-1])

def get_pixel(self, channel, index):
        """Get the RGB colour of a single pixel, on a single channel

:param channel: Channel, either 1, 2, 3 or 4 corresponding to numbers on Mote
        :param index: Index of pixel to set, from 0 up

"""

if channel > self._channel_count or channel < 1:
            raise ValueError("Channel index must be between 1 and 4")

if self._channels[channel-1] is None:
            raise ValueError("Please set up channel {channel} before using it".format(channel=channel))

if index >= len(self._channels[channel-1]):
            raise ValueError("Pixel index must be < {length}".format(length=len(self._channels[channel-1])))

return self._channels[channel-1][index]

def set_white_point(self, r, g, b):
        """Set the white point.

:param r: Red amount, from 0.0 to 1.0
        :param g: Green amount, from 0.0 to 1.0
        :param b: Blue amount, from 0.0 to 1.0

"""

self.white_point = (r, g, b)

def set_pixel(self, channel, index, r, g, b, brightness=None):
        """Set the RGB colour of a single pixel, on a single channel

:param channel: Channel, either 1, 2, 3 or 4 corresponding to numbers on Mote
        :param index: Index of pixel to set, from 0 up
        :param r: Amount of red: 0-255
        :param g: Amount of green: 0-255
        :param b: Amount of blue: 0-255
        :param brightness: (Optional) brightness of pixel from 0.0 to 1.0. Will scale R,G,B accordingly.

"""

if channel > self._channel_count or channel < 1:
            raise ValueError("Channel index must be between 1 and 4")

if self._channels[channel-1] is None:
            raise ValueError("Please set up channel {channel} before using it!".format(channel=channel))

if index >= len(self._channels[channel-1]):
            raise ValueError("Pixel index must be < {length}".format(length=len(self._channels[channel-1])))

if brightness is None and self._channels[channel-1][index] is not None:
            brightness = self._channels[channel-1][index][3]

self._channels[channel-1][index] = (r & 0xff, g & 0xff, b & 0xff,  brightness)

def clear(self, channel=None):
        """Clear the buffer of a specific or all channels

:param channel: If set, clear a specific channel, otherwise all (default None)

"""

if channel is None:
            for index, data in enumerate(self._channels):
                if data is not None:
                    self.clear(index+1)
            return

if channel > self._channel_count or channel < 1:
            raise ValueError("Channel index must be between 1 and 4")

if self._channels[channel-1] is None:
            raise ValueError("Please set up channel {channel} before using it!".format(channel=channel))

self._channels[channel-1] = [(0,0,0,1.0)] * len(self._channels[channel-1])

def show(self):
        """Send the pixel buffer to the hardware"""

buf = bytearray() 
        for index, data in enumerate(self._channels):
            if data is None: continue

for pixel in data:
                r, g, b, brightness = pixel
                r, g, b = [int(x * brightness * self.white_point[i]) for i, x in enumerate([r, g, b])]
                buf.append(b)
                buf.append(g)
                buf.append(r)

self.port.write(b'mote')
        self.port.write(b'o')
        self.port.write(buf)

def set_all(self, r, g, b, brightness=None, channel=None):
        """Set the RGB value and optionally brightness of all pixels

If you don't supply a brightness value, the last value set for each pixel be kept.

:param r: Amount of red: 0 to 255
        :param g: Amount of green: 0 to 255
        :param b: Amount of blue: 0 to 255
        :param brightness: Brightness: 0.0 to 1.0 (default around 0.2)
        :param channel: Optional channel: 1, 2, 3 or 4 (default to all)

"""

if channel in range(1, self._channel_count + 1):
            for x in range(NUM_PIXELS_PER_CHANNEL):
                self.set_pixel(channel, x, r, g, b, brightness)
            return

for c in range(1, self._channel_count + 1):
            if self._channels[c - 1] is None:
                continue
            for x in range(len(self._channels[c - 1])):
                self.set_pixel(c, x, r, g, b, brightness)

def set_brightness(self, brightness):
        """Set the brightness of all pixels

This sets the brightness of each pixel individually, it can be overriden
        by supplying the brightness argument to set_pixel.

:param brightness: Brightness: 0.0 to 1.0
        
        """

if not 0.0 <= brightness <= 1.0:
            raise ValueError("Brightness should be between 0.0 and 1.0, was: {}".format(brightness))

for channel in range(self._channel_count):
            pixels = self.get_pixel_count(channel + 1)
            for pixel in range(pixels):
                r, g, b, br = self._channels[channel][pixel]
                self._channels[channel][pixel] = (r, g, b, brightness)

def set_clear_on_exit(self, value=True):
        """Set whether Mote should be cleared upon exit.

By default Mote will leave the pixels on upon exit, but calling::

mote.set_clear_on_exit()

Will ensure that they are cleared.
        
        """

self._clear_on_exit = value

def __exit__(self):
        if self._clear_on_exit:
            self.clear()

self.port.close()

if __name__ == "__main__":
    from colorsys import hsv_to_rgb
    mote = Mote()

num_pixels = 16

mote.configure_channel(1, num_pixels, False)
    mote.configure_channel(2, num_pixels, False)
    mote.configure_channel(3, num_pixels, False)
    mote.configure_channel(4, num_pixels, False)

colors = [
        (255,   0,   0),
        (0,   255,   0),
        (0,     0, 255),
        (255, 255, 255)
    ]

try:
        for step in range(4):
            for channel in range(4):
                for pixel in range(num_pixels):
                    r, g, b = colors[channel]
                    mote.set_pixel(channel + 1, pixel, r, g, b)
                    mote.show()
                    time.sleep(0.01)

colors.append(colors.pop(0))

for step in range(170):
            for channel in range(4):
                for pixel in range(num_pixels):
                    r, g, b = [int(c * 0.99) for c in mote.get_pixel(channel + 1, pixel)]
                    mote.set_pixel(channel + 1, pixel, r, g, b)

time.sleep(0.001)
            mote.show()

brightness = 0
        for h in range(10000):
            for channel in range(4):
                for pixel in range(num_pixels):
                    hue = (h + (channel * num_pixels * 4) + (pixel * 4)) % 360
                    r, g, b = [int(c * brightness) for c in hsv_to_rgb(hue/360.0, 1.0, 1.0)]
                    mote.set_pixel(channel + 1, pixel, r, g, b)
            mote.show()
            time.sleep(0.01)
            if brightness < 255: brightness += 1

except KeyboardInterrupt:
        mote.clear()
        mote.show()
        time.sleep(0.1)

${this.title}

Code Editor : __init__.py

Code Editor : init.py