Merge pull request #1840 from makermelissa/main

Add Rotary Gif Players

Author: makermelissa

Raspberry_Pi_Animated_Gif_Player/animatedgif.py

@@ -0,0 +1,122 @@
+import os
+import time
+from PIL import Image, ImageOps
+
+# pylint: disable=too-few-public-methods
+class Frame:
+    def __init__(self, duration=0):
+        self.duration = duration
+        self.image = None
+
+
+# pylint: enable=too-few-public-methods
+
+
+class AnimatedGif:
+    def __init__(self, display, include_delays=True, folder=None):
+        self._frame_count = 0
+        self._loop = 0
+        self._index = 0
+        self._duration = 0
+        self._gif_files = []
+        self._frames = []
+        self._running = True
+        self.display = display
+        self.include_delays = include_delays
+        if folder is not None:
+            self.load_files(folder)
+            self.run()
+
+    def advance(self):
+        self._index = (self._index + 1) % len(self._gif_files)
+
+    def back(self):
+        self._index = (self._index - 1 + len(self._gif_files)) % len(self._gif_files)
+
+    def load_files(self, folder):
+        gif_files = [f for f in os.listdir(folder) if f.endswith(".gif")]
+        gif_folder = folder
+        if gif_folder[:-1] != "/":
+            gif_folder += "/"
+        for gif_file in gif_files:
+            image = Image.open(gif_folder + gif_file)
+            # Only add animated Gifs
+            if image.is_animated:
+                self._gif_files.append(gif_folder + gif_file)
+
+        print("Found", self._gif_files)
+        if not self._gif_files:
+            print("No Gif files found in current folder")
+            exit()  # pylint: disable=consider-using-sys-exit
+
+    def preload(self):
+        image = Image.open(self._gif_files[self._index])
+        print("Loading {}...".format(self._gif_files[self._index]))
+        if "duration" in image.info:
+            self._duration = image.info["duration"]
+        else:
+            self._duration = 0
+        if "loop" in image.info:
+            self._loop = image.info["loop"]
+        else:
+            self._loop = 1
+        self._frame_count = image.n_frames
+        self._frames.clear()
+        for frame in range(self._frame_count):
+            image.seek(frame)
+            # Create blank image for drawing.
+            # Make sure to create image with mode 'RGB' for full color.
+            frame_object = Frame(duration=self._duration)
+            if "duration" in image.info:
+                frame_object.duration = image.info["duration"]
+            frame_object.image = ImageOps.pad(  # pylint: disable=no-member
+                image.convert("RGB"),
+                (self._width, self._height),
+                method=Image.NEAREST,
+                color=(0, 0, 0),
+                centering=(0.5, 0.5),
+            )
+            self._frames.append(frame_object)
+
+    def play(self):
+        self.preload()
+        current_frame = 0
+        last_action = None
+        # Check if we have loaded any files first
+        if not self._gif_files:
+            print("There are no Gif Images loaded to Play")
+            return False
+        self.update_display(self._frames[current_frame].image)
+        while self._running:
+            action = self.get_next_value()
+            if action:
+                if not last_action:
+                    last_action = action
+                if action == "click":
+                    self.advance()
+                    return False
+                elif int(action) < int(last_action):
+                    current_frame -= 1
+                else:
+                    current_frame += 1
+                current_frame %= self._frame_count
+                frame_object = self._frames[current_frame]
+                start_time = time.monotonic()
+                self.update_display(frame_object.image)
+                if self.include_delays:
+                    remaining_delay = frame_object.duration / 1000 - (
+                        time.monotonic() - start_time
+                    )
+                    if remaining_delay > 0:
+                        time.sleep(remaining_delay)
+                last_action = action
+                if self._loop == 1:
+                    return True
+                if self._loop > 0:
+                    self._loop -= 1
+
+    def run(self):
+        while self._running:
+            auto_advance = self.play()
+            if auto_advance:
+                self.advance()

Raspberry_Pi_Animated_Gif_Player/code.py

@@ -0,0 +1,24 @@
+import usb_cdc
+import rotaryio
+import board
+import digitalio
+
+serial = usb_cdc.data
+encoder = rotaryio.IncrementalEncoder(board.ROTA, board.ROTB)
+button = digitalio.DigitalInOut(board.SWITCH)
+button.switch_to_input(pull=digitalio.Pull.UP)
+
+last_position = None
+button_state = False
+
+while True:
+    position = encoder.position
+    if last_position is None or position != last_position:
+        serial.write(bytes(str(position) + ",", "utf-8"))
+    last_position = position
+    print(button.value)
+    if not button.value and not button_state:
+        button_state = True
+    if button.value and button_state:
+        serial.write(bytes("click,", "utf-8"))
+        button_state = False

Raspberry_Pi_Animated_Gif_Player/mini_pitft_player.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
+# SPDX-License-Identifier: MIT
+
+"""
+This example is for use on (Linux) computers that are using CPython with
+Adafruit Blinka to support CircuitPython libraries. CircuitPython does
+not support PIL/pillow (python imaging library)!
+
+Author(s): Melissa LeBlanc-Williams for Adafruit Industries
+"""
+import digitalio
+import board
+from animatedgif import AnimatedGif
+import numpy  # pylint: disable=unused-import
+from adafruit_seesaw import seesaw, rotaryio, digitalio as ss_digitalio
+from adafruit_rgb_display import st7789
+
+seesaw = seesaw.Seesaw(board.I2C(), addr=0x36)
+
+seesaw_product = (seesaw.get_version() >> 16) & 0xFFFF
+print("Found product {}".format(seesaw_product))
+if seesaw_product != 4991:
+    print("Wrong firmware loaded? Make sure you have a rotary encoder connected.")
+
+seesaw.pin_mode(24, seesaw.INPUT_PULLUP)
+button = ss_digitalio.DigitalIO(seesaw, 24)
+encoder = rotaryio.IncrementalEncoder(seesaw)
+
+# Change to match your display
+BUTTON_UP = board.D23
+BUTTON_DOWN = board.D24
+
+# Configuration for CS and DC pins (these are PiTFT defaults):
+cs_pin = digitalio.DigitalInOut(board.CE0)
+dc_pin = digitalio.DigitalInOut(board.D25)
+
+
+def init_button(pin):
+    digital_button = digitalio.DigitalInOut(pin)
+    digital_button.switch_to_input(pull=digitalio.Pull.UP)
+    return digital_button
+
+
+class TFTAnimatedGif(AnimatedGif):
+    def __init__(self, display, include_delays=True, folder=None):
+        self._width = display.width
+        self._height = display.height
+        self.up_button = init_button(BUTTON_UP)
+        self.down_button = init_button(BUTTON_DOWN)
+        self._last_position = None
+        self._button_state = False
+        super().__init__(display, include_delays=include_delays, folder=folder)
+
+    def get_next_value(self):
+        while self._running:
+            position = -encoder.position
+            if position != self._last_position:
+                self._last_position = position
+                return str(position)
+            elif not button.value and not self._button_state:
+                self._button_state = True
+                return str("click")
+            elif button.value and self._button_state:
+                self._button_state = False
+            if not self.up_button.value or not self.down_button.value:
+                self._running = False
+        return None
+
+    def update_display(self, image):
+        self.display.image(image)
+
+
+# Config for display baudrate (default max is 64mhz):
+BAUDRATE = 64000000
+
+# Setup SPI bus using hardware SPI:
+spi = board.SPI()
+
+# Create the display:
+disp = st7789.ST7789(
+    spi,
+    height=240,
+    y_offset=80,
+    rotation=180,
+    cs=cs_pin,
+    dc=dc_pin,
+    rst=None,
+    baudrate=BAUDRATE,
+)
+
+gif_player = TFTAnimatedGif(disp, include_delays=False, folder="images")

Raspberry_Pi_Animated_Gif_Player/pygame_player.py

@@ -0,0 +1,87 @@
+"""
+This example is for use on (Linux) computers that are using CPython with
+Adafruit Blinka to support CircuitPython libraries. CircuitPython does
+not support PIL/pillow (python imaging library)!
+
+Author(s): Melissa LeBlanc-Williams for Adafruit Industries
+"""
+import serial
+import adafruit_board_toolkit.circuitpython_serial
+from animatedgif import AnimatedGif
+import pygame
+
+port = None
+
+
+def detect_port():
+    """
+    Detect the port automatically
+    """
+    comports = adafruit_board_toolkit.circuitpython_serial.data_comports()
+    ports = [comport.device for comport in comports]
+    if len(ports) >= 1:
+        if len(ports) > 1:
+            print("Multiple devices detected, using the first detected port.")
+        return ports[0]
+    raise RuntimeError(
+        "Unable to find any CircuitPython Devices with the CDC data port enabled."
+    )
+
+
+port = serial.Serial(
+    detect_port(),
+    9600,
+    parity="N",
+    rtscts=False,
+    xonxoff=False,
+    exclusive=True,
+)
+
+
+class PyGameAnimatedGif(AnimatedGif):
+    def __init__(self, display, include_delays=True, folder=None):
+        self._width, self._height = pygame.display.get_surface().get_size()
+        self._incoming_packet = b""
+        super().__init__(display, include_delays=include_delays, folder=folder)
+
+    def get_next_value(self):
+        if not port:
+            return None
+        while port.in_waiting:
+            self._incoming_packet += port.read(port.in_waiting)
+        while (
+            self._running
+            and not len(self._incoming_packet)
+            and self._incoming_packet.decode().find(",")
+        ):
+            self._incoming_packet += port.read(port.in_waiting)
+            self.check_pygame_events()
+
+        all_values = self._incoming_packet.decode().split(",")
+        value = all_values.pop(0)
+        self._incoming_packet = ",".join(all_values).encode("utf-8")
+        return value
+
+    def check_pygame_events(self):
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                self._running = False
+            elif event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_ESCAPE:
+                    self._running = False
+
+    def update_display(self, image):
+        pilImage = image
+        self.display.blit(
+            pygame.image.fromstring(pilImage.tobytes(), pilImage.size, pilImage.mode),
+            (0, 0),
+        )
+        pygame.display.flip()
+
+
+pygame.init()
+pygame.mouse.set_visible(False)
+screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
+gif_player = PyGameAnimatedGif(screen, include_delays=False, folder="images")
+pygame.mouse.set_visible(True)
+port.close()