custom LED animations code

Author: FoamyGuy

Custom_LED_Animations/conways/code.py

@@ -0,0 +1,20 @@
+import board
+import neopixel
+
+from rainbowsweep import RainbowSweepAnimation
+
+# Update to match the pin connected to your NeoPixels
+pixel_pin = board.D10
+# Update to match the number of NeoPixels you have connected
+pixel_num = 32
+
+# initialize the neopixels. Change out for dotstars if needed.
+pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.02, auto_write=False)
+
+# initialize the animation
+rainbowsweep = RainbowSweepAnimation(pixels, speed=0.05, color=0x000000, sweep_speed=0.1,
+                                     sweep_direction=RainbowSweepAnimation.DIRECTION_END_TO_START)
+
+while True:
+    # call animation to show the next animation frame
+    rainbowsweep.animate()

Custom_LED_Animations/conways/conways.py

@@ -0,0 +1,143 @@
+# SPDX-FileCopyrightText: 2024 Tim Cocks for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Adapted From `adafruit_led_animation.animation.rainbow`
+"""
+
+from adafruit_led_animation.animation import Animation
+from adafruit_led_animation.color import BLACK, colorwheel
+from adafruit_led_animation import MS_PER_SECOND, monotonic_ms
+
+
+class RainbowSweepAnimation(Animation):
+    """
+    The classic rainbow color wheel that gets swept across by another specified color.
+
+    :param pixel_object: The initialised LED object.
+    :param float speed: Animation refresh rate in seconds, e.g. ``0.1``.
+    :param float sweep_speed: How long in seconds to wait between sweep steps
+    :param float period: Period to cycle the rainbow over in seconds.  Default 1.
+    :param sweep_direction: which way to sweep across the rainbow. Must be one of
+      DIRECTION_START_TO_END or DIRECTION_END_TO_START
+    :param str name: Name of animation (optional, useful for sequences and debugging).
+
+    """
+
+    # constants to represent the different directions
+    DIRECTION_START_TO_END = 0
+    DIRECTION_END_TO_START = 1
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self, pixel_object, speed, color, sweep_speed=0.3, period=1, name=None, sweep_direction=DIRECTION_START_TO_END
+    ):
+        super().__init__(pixel_object, speed, color, name=name)
+        self._period = period
+        # internal var step used inside of color generator
+        self._step = 256 // len(pixel_object)
+
+        # internal var wheel_index used inside of color generator
+        self._wheel_index = 0
+
+        # instance of the generator
+        self._generator = self._color_wheel_generator()
+
+        # convert swap speed from seconds to ms and store it
+        self._sweep_speed = sweep_speed * 1000
+
+        # set the initial sweep index
+        self.sweep_index = len(pixel_object)
+
+        # internal variable to store the timestamp of when a sweep step occurs
+        self._last_sweep_time = 0
+
+        # store the direction argument
+        self.direction = sweep_direction
+
+    # this animation supports on cycle complete callbacks
+    on_cycle_complete_supported = True
+
+    def _color_wheel_generator(self):
+        # convert period to ms
+        period = int(self._period * MS_PER_SECOND)
+
+        # how many pixels in the strand
+        num_pixels = len(self.pixel_object)
+
+        # current timestamp
+        last_update = monotonic_ms()
+
+        cycle_position = 0
+        last_pos = 0
+        while True:
+            cycle_completed = False
+            # time vars
+            now = monotonic_ms()
+            time_since_last_draw = now - last_update
+            last_update = now
+
+            # cycle position vars
+            pos = cycle_position = (cycle_position + time_since_last_draw) % period
+
+            # if it's time to signal cycle complete
+            if pos < last_pos:
+                cycle_completed = True
+
+            # update position var for next iteration
+            last_pos = pos
+
+            # calculate wheel_index
+            wheel_index = int((pos / period) * 256)
+
+            # set all pixels to their color based on the wheel color and step
+            self.pixel_object[:] = [
+                colorwheel(((i * self._step) + wheel_index) % 255) for i in range(num_pixels)
+            ]
+
+            # if it's time for a sweep step
+            if self._last_sweep_time + self._sweep_speed <= now:
+
+                # udpate sweep timestamp
+                self._last_sweep_time = now
+
+                # decrement the sweep index
+                self.sweep_index -= 1
+
+                # if it's finished the last step
+                if self.sweep_index == -1:
+                    # reset it to the number of pixels in the strand
+                    self.sweep_index = len(self.pixel_object)
+
+            # if end to start direction
+            if self.direction == self.DIRECTION_END_TO_START:
+                # set the current pixels at the end of the strand to the specified color
+                self.pixel_object[self.sweep_index:] = [self.color] * (len(self.pixel_object) - self.sweep_index)
+
+            # if start to end direction
+            elif self.direction == self.DIRECTION_START_TO_END:
+                # set the pixels at the begining of the strand to the specified color
+                inverse_index = len(self.pixel_object) - self.sweep_index
+                self.pixel_object[:inverse_index] = [self.color] * (inverse_index)
+
+            # update the wheel index
+            self._wheel_index = wheel_index
+
+            # signal cycle complete if it's time
+            if cycle_completed:
+                self.cycle_complete = True
+            yield
+
+
+    def draw(self):
+        """
+        draw the current frame of the animation
+        :return:
+        """
+        next(self._generator)
+
+    def reset(self):
+        """
+        Resets the animation.
+        """
+        self._generator = self._color_wheel_generator()

Custom_LED_Animations/rainbow_sweep/code.py

@@ -0,0 +1,19 @@
+import board
+import neopixel
+
+from snake import SnakeAnimation
+
+# Update to match the pin connected to your NeoPixels
+pixel_pin = board.D10
+# Update to match the number of NeoPixels you have connected
+pixel_num = 32
+
+# initialize the neopixels. Change out for dotstars if needed.
+pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.02, auto_write=False)
+
+# initialize the animation
+snake = SnakeAnimation(pixels, speed=0.1, color=0xff00ff, width=8, height=4)
+
+while True:
+    # call animation to show the next animation frame
+    snake.animate()

Custom_LED_Animations/rainbow_sweep/rainbowsweep.py

@@ -0,0 +1,164 @@
+# SPDX-FileCopyrightText: 2024 Tim Cocks
+#
+# SPDX-License-Identifier: MIT
+"""
+SnakeAnimation helper class
+"""
+from micropython import const
+
+from adafruit_led_animation.animation import Animation
+from adafruit_led_animation.grid import PixelGrid, HORIZONTAL
+import random
+
+
+class SnakeAnimation(Animation):
+    UP = const(0x00)
+    DOWN = const(0x01)
+    LEFT = const(0x02)
+    RIGHT = const(0x03)
+    ALL_DIRECTIONS = [UP, DOWN, LEFT, RIGHT]
+    DIRECTION_OFFSETS = {
+        DOWN: (0, 1),
+        UP: (0, -1),
+        RIGHT: (1, 0),
+        LEFT: (-1, 0)
+    }
+
+    def __init__(self, pixel_object, speed, color, width, height, snake_length=3):
+        """
+        Renders a snake that slithers around the 2D grid of pixels
+        """
+        super().__init__(pixel_object, speed, color)
+
+        # how many segments the snake will have
+        self.snake_length = snake_length
+
+        # create a PixelGrid helper to access our strand as a 2D grid
+        self.pixel_grid = PixelGrid(pixel_object, width, height, orientation=HORIZONTAL, alternating=False)
+
+        # size variables
+        self.width = width
+        self.height = height
+
+        # list that will hold locations of snake segments
+        self.snake_pixels = []
+
+        # initialize the snake
+        self._new_snake()
+
+    def _clear_snake(self):
+        """
+        Clear the snake segments and turn off all pixels
+        """
+        while len(self.snake_pixels) > 0:
+            self.pixel_grid[self.snake_pixels.pop()] = 0x000000
+
+    def _new_snake(self):
+        """
+        Create a new single segment snake. The snake has a random
+        direction and location. Turn on the pixel representing the snake.
+        """
+        # choose a random direction and store it
+        self.direction = random.choice(SnakeAnimation.ALL_DIRECTIONS)
+
+        # choose a random starting tile
+        starting_tile = (random.randint(0, self.width - 1), random.randint(0, self.height - 1))
+
+        # add the starting tile to the list of segments
+        self.snake_pixels.append(starting_tile)
+
+        # turn on the pixel at the chosen location
+        self.pixel_grid[self.snake_pixels[0]] = self.color
+
+    def _can_move(self, direction):
+        """
+        returns true if the snake can move in the given direction
+        """
+        # location of the next tile if we would move that direction
+        next_tile = tuple(map(sum, zip(SnakeAnimation.DIRECTION_OFFSETS[direction], self.snake_pixels[0])))
+
+        # if the tile is one of the snake segments
+        if next_tile in self.snake_pixels:
+            # can't move there
+            return False
+
+        # if the tile is within the bounds of the grid
+        if 0 <= next_tile[0] < self.width and 0 <= next_tile[1] < self.height:
+            # can move there
+            return True
+
+        # return false if any other conditions not met
+        return False
+
+
+    def _choose_direction(self):
+        """
+        Choose a direction to go in. Could continue in same direction
+        as it's already going, or decide to turn to a dirction that
+        will allow movement.
+        """
+
+        # copy of all directions in a list
+        directions_to_check = list(SnakeAnimation.ALL_DIRECTIONS)
+
+        # if we can move the direction we're currently going
+        if self._can_move(self.direction):
+            # "flip a coin"
+            if random.random() < 0.5:
+                # on "heads" we stay going the same direction
+                return self.direction
+
+        # loop over the copied list of directions to check
+        while len(directions_to_check) > 0:
+            # choose a random one from the list and pop it out of the list
+            possible_direction = directions_to_check.pop(random.randint(0, len(directions_to_check)-1))
+            # if we can move the chosen direction
+            if self._can_move(possible_direction):
+                # return the chosen direction
+                return possible_direction
+
+        # if we made it through all directions and couldn't move in any of them
+        # then raise the SnakeStuckException
+        raise SnakeAnimation.SnakeStuckException
+
+
+    def draw(self):
+        """
+        Draw the current frame of the animation
+        """
+        # if the snake is currently the desired length
+        if len(self.snake_pixels) == self.snake_length:
+            # remove the last segment from the list and turn it's LED off
+            self.pixel_grid[self.snake_pixels.pop()] = 0x000000
+
+        # if the snake is less than the desired length
+        # e.g. because we removed one in the previous step
+        if len(self.snake_pixels) < self.snake_length:
+            # wrap with try to catch the SnakeStuckException
+            try:
+                # update the direction, could continue straight, or could change
+                self.direction = self._choose_direction()
+
+                # the location of the next tile where the head of the snake will move to
+                next_tile = tuple(map(sum, zip(SnakeAnimation.DIRECTION_OFFSETS[self.direction], self.snake_pixels[0])))
+
+                # insert the next tile at list index 0
+                self.snake_pixels.insert(0, next_tile)
+
+                # turn on the LED for the tile
+                self.pixel_grid[next_tile] = self.color
+
+            # if the snake exception is caught
+            except SnakeAnimation.SnakeStuckException:
+                # clear the snake to get rid of the old one
+                self._clear_snake()
+
+                # make a new snake
+                self._new_snake()
+
+    class SnakeStuckException(RuntimeError):
+        """
+        Exception indicating the snake is stuck and can't move in any direction
+        """
+        def __init__(self):
+            super().__init__("SnakeStuckException")

Custom_LED_Animations/snake/code.py

@@ -0,0 +1,21 @@
+import board
+import neopixel
+
+from sweep import SweepAnimation
+
+from adafruit_led_animation.color import PINK
+
+# Update to match the pin connected to your NeoPixels
+pixel_pin = board.D10
+# Update to match the number of NeoPixels you have connected
+pixel_num = 32
+
+# initialize the neopixels. Change out for dotstars if needed.
+pixels = neopixel.NeoPixel(pixel_pin, pixel_num, brightness=0.02, auto_write=False)
+
+# initialize the animation
+sweep = SweepAnimation(pixels, speed=0.05, color=PINK)
+
+while True:
+    # call animation to show the next animation frame
+    sweep.animate()