Added Palette Rotation Example

Author: Melissa LeBlanc-Williams

adafruit_featherwing/dotstar_featherwing.py

@@ -34,6 +34,10 @@
 import board
 import adafruit_dotstar as dotstar
 
+# Library Function Ideas
+# Gradient (probably just for example)
+#                   20                  40                  60                  80                  100
+
 class DotStarFeatherWing:
     """Class representing a `DotStar FeatherWing
        <https://www.adafruit.com/product/3449>`_.
@@ -48,21 +52,168 @@ def __init__(self, clock=board.D13, data=board.D11, brightness=0.2):
         self.rows = 6
         self.columns = 12
         self._brightness = brightness
+        self._auto_write = True
         self._dotstar = dotstar.DotStar(clock, data, self.rows * self.columns,
-                                        brightness=self._brightness)
+                                        brightness=self._brightness, auto_write=False)
 
     def __setitem__(self, indices, value):
-        x, y = indices
-        self._dotstar[y * self.columns + x] = value
+        """
+        indices can be one of two things:
+            x and y ints that are calculated to the DotStar index
+            a single int that specifies the DotStar index
+        value can be one of three things:
+                a (r,g,b) list/tuple
+                a (r,g,b, brightness) list/tuple
+                a single, longer int that contains RGB values, like 0xFFFFFF
+            brightness, if specified should be a float 0-1
+        """
+        self._dotstar[self._get_index(indices)] = value
+        self._update()
 
     def __getitem__(self, indices):
-        x, y = indices
-        return self._dotstar[y * self.columns + x]
+        return self._dotstar[self._get_index(indices)]
+
+    def _get_index(self, indices):
+        if isinstance(indices, int):
+            if not 0 <= indices < self.rows * self.columns:
+                raise ValueError('The index of {} is out of range'.format(indices))
+            return indices
+        elif isinstance(indices, slice):
+            return indices
+        elif len(indices) == 2:
+            x, y = indices
+            if not 0 <= x < self.columns:
+                raise ValueError('The X value of {} is out of range'.format(x))
+            if not 0 <= y < self.rows:
+                raise ValueError('The Y value of {} is out of range'.format(y))
+            return y * self.columns + x
+        else:
+            raise ValueError('Index must be 1 or 2 number')
+
+    def fill(self, color=0):
+        """
+        Fills all of the DotStars with a color or unlit if empty.
+
+        :param color: (Optional) The text or number to display (default=0)
+        :type color: list/tuple or int
+
+        This example shows various ways of using the fill() function
+
+        .. code-block:: python
 
-    def fill(self, color):
-        """Fills the wing with a color.
-           Does NOT update the LEDs.
+            import time
+            from adafruit_featherwing import dotstar_featherwing
+
+            dotstar = dotstar_featherwing.DotStarFeatherWing()
+            dotstar.fill((255, 255, 255)) # Fill White
+            time.sleep(1)
+            dotstar.fill((255, 255, 255, 0.5)) # Fill White Half Brightness
+            time.sleep(1)
+            dotstar.fill(0xFF0000) # Fill Red
+            time.sleep(1)
+            dotstar.fill() # Clear all lit DotStars
 
-           :param (int, int, int) color: the color to fill with
         """
         self._dotstar.fill(color)
+        self._update()
+
+    def show(self):
+        """
+        Update the DotStars. This is only needed if auto_write is set to False
+        This can be very useful for more advanced graphics effects.
+
+        This example changes the blink rate and prints out the current setting
+
+        .. code-block:: python
+
+            import time
+            from adafruit_featherwing import dotstar_featherwing
+
+            dotstar = dotstar_featherwing.DotStarFeatherWing()
+            dotstar.fill() # Clear any lit Dotstars
+            dotstar.auto_write = False
+            dotstar[0, 0] = (255, 255, 255) # Set White
+            time.sleep(1)
+            dotstar.show() # Update the DotStars
+
+        """
+        self._dotstar.show()
+
+    def shift_right(self, rotate=False):
+        """
+        Shift all pixels right
+
+        :param rotate: (Optional) Rotate the shifted pixel to the beginning (default=False)
+
+        This example shifts pixels
+
+        .. code-block:: python
+
+            import time
+            from adafruit_featherwing import dotstar_featherwing
+
+            dotstar = dotstar_featherwing.DotStarFeatherWing()
+            dotstar.fill() # Clear any lit Dotstars
+            dotstar.auto_write = False
+            dotstar[0, 0] = (255, 255, 255) # Set White
+            time.sleep(1)
+            dotstar.show() # Update the DotStars
+
+        """
+        for y in range(0, self.rows):
+            for x in range(self.columns - 1, 0, -1):
+                self._dotstar[y * self.columns + x] = self._dotstar[y * self.columns + x - 1]
+            lastPixel = self._dotstar[(y + 1) * self.columns - 1] if rotate else 0
+            self._dotstar[y * self.columns] = lastPixel
+        self._update()
+
+    def shift_left(self, rotate=False):
+        """Shift all pixels left"""
+        for y in range(0, self.rows):
+            for x in range(0, self.columns - 1):
+                self._dotstar[y * self.columns + x] = self._dotstar[y * self.columns + x + 1]
+            lastPixel = self._dotstar[y * self.columns] if rotate else 0
+            self._dotstar[(y + 1) * self.columns - 1] = lastPixel
+        self._update()
+
+    def shift_up(self, rotate=False):
+        """Shift all pixels up"""
+        for x in range(0, self.columns):
+            for y in range(self.rows - 1, 0, -1):
+                self._dotstar[y * self.columns + x] = self._dotstar[(y - 1) * self.columns + x]
+            lastPixel = self._dotstar[(self.rows - 1) * self.columns + x] if rotate else 0
+            self._dotstar[x] = lastPixel
+        self._update()
+
+    def shift_down(self, rotate=False):
+        """Shift all pixels down"""
+        for x in range(0, self.columns):
+            for y in range(0, self.rows - 1):
+                self._dotstar[y * self.columns + x] = self._dotstar[(y + 1) * self.columns + x]
+            lastPixel = self._dotstar[x] if rotate else 0
+            self._dotstar[(self.rows - 1) * self.columns + x] = lastPixel
+        self._update()
+
+    def _update(self):
+        if self._auto_write:
+            self._dotstar.show()
+
+    @property
+    def auto_write(self):
+        """Whether or not we are automatically updating
+        If set to false, be sure to call show() to update"""
+        return self._auto_write
+
+    @auto_write.setter
+    def auto_write(self, write):
+        if isinstance(write, bool):
+            self._auto_write = write
+
+    @property
+    def brightness(self):
+        """Overall brightness of the display"""
+        return self._dotstar.brightness
+
+    @brightness.setter
+    def brightness(self, brightness):
+        self._dotstar.brightness = min(max(brightness, 0.0), 1.0)

docs/examples.rst

@@ -19,5 +19,9 @@ Ensure your device works with this simple test.
     :caption: examples/featherwing_dotstar_simpletest.py
     :linenos:
 
+.. literalinclude:: ../examples/featherwing_dotstar_palettetest.py
+    :caption: examples/featherwing_dotstar_palettetest.py
+    :linenos:
+
 
 

examples/featherwing_dotstar_palettetest.py

@@ -0,0 +1,51 @@
+"""
+This creates a palette of colors, draws a pattern and
+rotates through the palette creating a moving rainbow.
+"""
+
+from math import sqrt,cos,sin,radians
+from adafruit_featherwing import dotstar_featherwing
+
+dotstar = dotstar_featherwing.DotStarFeatherWing()
+
+# Remap the calculated rotation to 0 - 255
+def remap(vector):
+    return int(((255 * vector + 85) * 0.75) + 0.5)
+
+# Calculate the Hue rotation starting with Red as 0 degrees
+def rotate(degrees):
+    cosA = cos(radians(degrees))
+    sinA = sin(radians(degrees))
+    red = cosA + (1.0 - cosA) / 3.0
+    green = 1./3. * (1.0 - cosA) + sqrt(1./3.) * sinA
+    blue = 1./3. * (1.0 - cosA) - sqrt(1./3.) * sinA
+    return (remap(red), remap(green), remap(blue))
+
+palette = []
+pixels = []
+
+# Generate a rainbow palette
+for degree in range(0, 360):
+    color = rotate(degree)
+    palette.append(color[0] << 16 | color[1] << 8 | color[2])
+
+# Create the Pattern
+for y in range(0, dotstar.rows):
+    for x in range(0, dotstar.columns):
+        pixels.append(x * 30 + y * -30)
+
+# Clear the screen
+dotstar.fill()
+
+# Start the Animation
+dotstar.auto_write = False
+while True:
+    for color in range(0, 360, 10):
+        for index in range(0, 72):
+            palette_index = pixels[index] + color
+            if palette_index >= 360:
+                palette_index -= 360
+            elif palette_index < 0:
+                palette_index += 360
+            dotstar[index] = palette[palette_index]
+        dotstar.show()

examples/featherwing_dotstar_simpletest.py

@@ -5,6 +5,7 @@
 
 from time import sleep
 import random
+from math import sqrt,cos,sin,radians
 from adafruit_featherwing import dotstar_featherwing
 
 dotstar = dotstar_featherwing.DotStarFeatherWing()
@@ -14,13 +15,46 @@
 def random_color():
     return random.randrange(0, 8) * 32
 
-for i in range(0, 15):
+# Fill screen with random colors at random brightnesses
+for i in range(0, 5):
     dotstar.fill((random_color(), random_color(), random_color()))
+    dotstar.brightness = random.randrange(2, 10) / 10
     sleep(.2)
 
-# MAIN LOOP
+# Set display to 30% brightness
+dotstar.brightness = 0.3
+
+# Create a gradiant drawing each pixel
+for x in range(0, dotstar.columns):
+    for y in range(dotstar.rows - 1, -1, -1):
+        dotstar[x, y] = (y * 42, 255, y * 42, 1)
+
+#Rotate everything left 36 frames
+for i in range(0, 36):
+    dotstar.shift_down(True)
+
+# Draw dual gradiant and then update
+dotstar.auto_write = False
+for y in range(0, dotstar.rows):
+    for x in range(0, 6):
+        dotstar[x, y] = (y * 84, x * 42, x * 42, 1)
+    for x in range(6, 12):
+        dotstar[x, y] = (255 - (y * 84), 255 - ((x - 6) * 42), 255 - ((x - 6) * 42), 1)
+
+# Rotate everything left 36 frames
+for i in range(0, 36):
+    dotstar.shift_left(True)
+    dotstar.shift_up(True)
+    dotstar.show()
+dotstar.auto_write = True
+
+# Shift without rotating in bits for an animated screen wipe
+for i in range(0, 6):
+    dotstar.shift_up()
+
+# Show pixels in random locations of random color
+# Bottom left corner is (0,0)
 while True:
-    # Fill screen with a random color
     x = random.randrange(0, dotstar.columns)
     y = random.randrange(0, dotstar.rows)
     dotstar[x, y] = (random_color(), random_color(), random_color())