Merge pull request #2592 from makermelissa/main

Animated Message Board Working

Author: TheKitty

Matrix_Portal_S3_Message_Board/code.py

@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import time
+from adafruit_matrixportal.matrix import Matrix
+from messageboard import MessageBoard
+from messageboard.fontpool import FontPool
+from messageboard.message import Message
+
+matrix = Matrix(width=128, height=16, bit_depth=5)
+messageboard = MessageBoard(matrix)
+messageboard.set_background("images/background.bmp")
+fontpool = FontPool()
+fontpool.add_font("arial", "fonts/Arial-10.pcf")
+
+while True:
+    message = Message(fontpool.find_font("arial"), mask_color=0xFF00FF, opacity=0.8)
+    message.add_image("images/maskedstar.bmp")
+    message.add_text("Hello World!", color=0xFFFF00, x_offset=2, y_offset=2)
+    messageboard.animate(message, "Scroll", "in_from_right")
+    time.sleep(1)
+    messageboard.animate(message, "Scroll", "out_to_left")

Matrix_Portal_S3_Message_Board/demo.py

@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import time
+from adafruit_matrixportal.matrix import Matrix
+from messageboard import MessageBoard
+from messageboard.fontpool import FontPool
+from messageboard.message import Message
+
+matrix = Matrix(width=128, height=16, bit_depth=5)
+messageboard = MessageBoard(matrix)
+messageboard.set_background("images/background.bmp")
+
+fontpool = FontPool()
+fontpool.add_font("arial", "fonts/Arial-10.pcf")
+fontpool.add_font("comic", "fonts/Comic-10.pcf")
+fontpool.add_font("dejavu", "fonts/DejaVuSans-10.pcf")
+
+message = Message(fontpool.find_font("terminal"), opacity=0.8)
+message.add_image("images/maskedstar.bmp")
+message.add_text("Hello World!", color=0xFFFF00, x_offset=2, y_offset=2)
+
+message1 = Message(fontpool.find_font("dejavu"))
+
+message2 = Message(fontpool.find_font("comic"), mask_color=0x00FF00)
+print("add blinka")
+message2.add_image("images/maskedblinka.bmp")
+print("add text")
+message2.add_text("CircuitPython", color=0xFFFF00, y_offset=-2)
+
+message3 = Message(fontpool.find_font("dejavu"))
+message3.add_text("circuitpython.com", color=0xFF0000)
+
+message4 = Message(fontpool.find_font("arial"))
+message4.add_text("Buy Electronics", color=0xFFFFFF)
+
+while True:
+    message1.clear()
+    message1.add_text("Scroll Text In", color=0xFF0000)
+
+    messageboard.animate(message1, "Scroll", "in_from_left")
+    time.sleep(1)
+    message1.clear()
+    message1.add_text("Change Messages")
+    messageboard.animate(message1, "Static", "show")
+    time.sleep(1)
+    message1.clear()
+    message1.add_text("And Scroll Out")
+
+    messageboard.animate(message1, "Static", "show")
+    messageboard.animate(message1, "Scroll", "out_to_right")
+    time.sleep(1)
+
+    message1.clear()
+    message1.add_text("Or more effects like looping   ", color=0xFFFF00)
+    messageboard.animate(
+        message1, "Split", "in_vertically"
+    )  # Split never completely joins
+    messageboard.animate(
+        message1, "Loop", "left"
+    )  # Text too high (probably from split)
+    messageboard.animate(
+        message1, "Static", "flash", count=3
+    )  # Flashes in weird positions
+
+    messageboard.animate(message1, "Split", "out_vertically")
+    time.sleep(1)
+
+    messageboard.animate(message2, "Static", "fade_in")
+    time.sleep(1)
+    messageboard.animate(message2, "Static", "fade_out")
+
+    messageboard.set_background(0x00FF00)
+    messageboard.animate(message3, "Scroll", "in_from_top")
+    time.sleep(1)
+    messageboard.animate(message3, "Scroll", "out_to_bottom")
+    messageboard.set_background("images/background.bmp")
+
+    messageboard.animate(message4, "Scroll", "in_from_right")
+    time.sleep(1)

Matrix_Portal_S3_Message_Board/fonts/Arial-10.pcf

@@ -0,0 +1,158 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import bitmaptools
+import displayio
+import adafruit_imageload
+from .doublebuffer import DoubleBuffer
+from .message import Message
+
+
+class MessageBoard:
+    def __init__(self, matrix):
+        self.fonts = {}
+        self.display = matrix.display
+        self._buffer_width = self.display.width * 2
+        self._buffer_height = self.display.height * 2
+        self._dbl_buf = DoubleBuffer(
+            self.display, self._buffer_width, self._buffer_height
+        )
+        self._background = None
+        self.set_background()  # Set to black
+        self._position = (0, 0)
+
+    def set_background(self, file_or_color=0x000000):
+        """The background image to a bitmap file."""
+        if isinstance(file_or_color, str):  # its a filenme:
+            background, bg_shader = adafruit_imageload.load(file_or_color)
+            self._dbl_buf.shader = bg_shader
+            self._background = background
+        elif isinstance(file_or_color, int):
+            # Make a background color fill
+            bg_shader = displayio.ColorConverter(
+                input_colorspace=displayio.Colorspace.RGB565
+            )
+            background = displayio.Bitmap(
+                self.display.width, self.display.height, 65535
+            )
+            background.fill(displayio.ColorConverter().convert(file_or_color))
+            self._dbl_buf.shader = bg_shader
+            self._background = background
+        else:
+            raise RuntimeError("Unknown type of background")
+
+    def animate(self, message, animation_class, animation_function, **kwargs):
+        anim_class = __import__(
+            f"{self.__module__}.animations.{animation_class.lower()}"
+        )
+        anim_class = getattr(anim_class, "animations")
+        anim_class = getattr(anim_class, animation_class.lower())
+        anim_class = getattr(anim_class, animation_class)
+        animation = anim_class(
+            self.display, self._draw, self._position
+        )  # Instantiate the class
+        # Call the animation function and pass kwargs along with the message (positional)
+        anim_func = getattr(animation, animation_function)
+        anim_func(message, **kwargs)
+
+    def _draw(
+        self,
+        image,
+        x,
+        y,
+        opacity=None,
+        mask_color=0xFF00FF,
+        blendmode=bitmaptools.BlendMode.Normal,
+        post_draw_position=None,
+    ):
+        """Draws a message to the buffer taking its current settings into account.
+        It also sets the current position and performs a swap.
+        """
+        self._position = (x, y)
+        buffer_x_offset = self._buffer_width - self.display.width
+        buffer_y_offset = self._buffer_height - self.display.height
+
+        # Image can be a message in which case its properties will be used
+        if isinstance(image, Message):
+            if opacity is None:
+                opacity = image.opacity
+            mask_color = image.mask_color
+            blendmode = image.blendmode
+            image = image.buffer
+        if opacity is None:
+            opacity = 1.0
+
+        if mask_color > 65535:
+            mask_color = displayio.ColorConverter().convert(mask_color)
+
+        # Blit the background
+        bitmaptools.blit(
+            self._dbl_buf.active_buffer,
+            self._background,
+            buffer_x_offset,
+            buffer_y_offset,
+        )
+
+        # If the image is wider than the display buffer, we need to shrink it
+        if x + buffer_x_offset < 0:
+            new_image = displayio.Bitmap(
+                image.width - self.display.width, image.height, 65535
+            )
+            bitmaptools.blit(
+                new_image,
+                image,
+                0,
+                0,
+                x1=self.display.width,
+                y1=0,
+                x2=image.width,
+                y2=image.height,
+            )
+            x += self.display.width
+            image = new_image
+
+        # If the image is taller than the display buffer, we need to shrink it
+        if y + buffer_y_offset < 0:
+            new_image = displayio.Bitmap(
+                image.width, image.height - self.display.height, 65535
+            )
+            bitmaptools.blit(
+                new_image,
+                image,
+                0,
+                0,
+                x1=0,
+                y1=self.display.height,
+                x2=image.width,
+                y2=image.height,
+            )
+            y += self.display.height
+            image = new_image
+
+        # Clear the foreground buffer
+        foreground_buffer = displayio.Bitmap(
+            self._buffer_width, self._buffer_height, 65535
+        )
+        foreground_buffer.fill(mask_color)
+
+        bitmaptools.blit(
+            foreground_buffer, image, x + buffer_x_offset, y + buffer_y_offset
+        )
+
+        # Blend the foreground buffer into the main buffer
+        bitmaptools.alphablend(
+            self._dbl_buf.active_buffer,
+            self._dbl_buf.active_buffer,
+            foreground_buffer,
+            displayio.Colorspace.RGB565,
+            1.0,
+            opacity,
+            blendmode=blendmode,
+            skip_source2_index=mask_color,
+        )
+        self._dbl_buf.show()
+
+        # Allow for an override of the position after drawing (needed for split effects)
+        if post_draw_position is not None and isinstance(post_draw_position, tuple):
+            self._position = post_draw_position

Matrix_Portal_S3_Message_Board/fonts/Comic-10.pcf

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import time
+
+
+class Animation:
+    def __init__(self, display, draw_callback, starting_position=(0, 0)):
+        self._display = display
+        self._position = starting_position
+        self._draw = draw_callback
+
+    @staticmethod
+    def _wait(start_time, duration):
+        """Uses time.monotonic() to wait from the start time for a specified duration"""
+        while time.monotonic() < (start_time + duration):
+            pass
+        return time.monotonic()
+
+    def _get_centered_position(self, message):
+        return int(self._display.width / 2 - message.buffer.width / 2), int(
+            self._display.height / 2 - message.buffer.height / 2
+        )