bluer-sbc 8.3.1__py3-none-any.whl

bluer_sbc/hardware/hat/abstract.py

@@ -0,0 +1,136 @@
+import math
+import time
+
+from bluer_sbc.hardware.hardware import Hardware
+from bluer_sbc.logger import logger
+
+
+class Abstract_Hat(Hardware):
+    def __init__(self):
+        super().__init__()
+
+        self.switch_pin = -1
+
+        self.green_switch_pin = -1
+        self.red_switch_pin = -1
+        self.trigger_pin = -1
+
+        self.looper_pin = -1  # red led
+        self.incoming_pin = -1  # yellow led
+        self.data_pin = -1  # green led
+        self.outgoing_pin = -1  # blue led
+
+        self.green_led_pin = -1
+        self.red_led_pin = -1
+
+        self.pin_history = {}
+
+    def activated(self, pin):
+        """
+        is pin activated?
+        :param pin: pin number
+        :return: True / False
+        """
+        if pin in self.input_pins:
+            return self.input(pin) == False
+
+        return False
+
+    def input(self, pin):
+        """
+        read pin input.
+        :param pin: pin number
+        :return: True / False
+        """
+        return True
+
+    @property
+    def input_pins(self):
+        return [
+            pin
+            for pin in [
+                self.switch_pin,
+                self.green_switch_pin,
+                self.red_switch_pin,
+                self.trigger_pin,
+            ]
+            if pin != -1
+        ]
+
+    def output(self, pin, output):
+        """
+        set pin to output
+        :param pin: pin number
+        :param output: True / False
+        :return: self
+        """
+        return self
+
+    @property
+    def output_pins(self):
+        return [
+            pin
+            for pin in [
+                self.looper_pin,
+                self.incoming_pin,
+                self.data_pin,
+                self.outgoing_pin,
+                self.green_led_pin,
+                self.red_led_pin,
+            ]
+            if pin != -1
+        ]
+
+    def pulse(self, pin=None, frequency=None):
+        """
+        pulse pin.
+        :param pin: pin number / "data" / "incoming" / "loop" / "outputs"
+        :param frequency: frequency
+        :return: self
+        """
+        super().pulse(pin, frequency)
+
+        if pin == "data":
+            pin = self.data_pin
+
+        if pin == "incoming":
+            pin = self.incoming_pin
+
+        if pin == "loop":
+            pin = self.looper_pin
+
+        if pin == "outputs":
+            for index, pin in enumerate(self.output_pins):
+                self.pulse(pin, index)
+
+            return self
+
+        if pin is None:
+            for pin in self.output_pins:
+                self.pulse(pin, frequency)
+
+            return self
+
+        self.pin_history[pin] = (
+            not bool(self.pin_history.get(pin, False))
+            if frequency is None
+            else (lambda x: x - math.floor(x))(time.time() * (10 + frequency)) >= 0.5
+        )
+
+        return self.output(pin, self.pin_history[pin])
+
+    def release(self):
+        """
+        release self
+        :return: self
+        """
+        return self
+
+    def setup(self, pin, what, pull_up_down=None):
+        """
+        Set up pin.
+        :param pin: pin number
+        :param what: "input" / "output"
+        :return: self
+        """
+        return self

bluer_sbc/hardware/hat/prototype.py

@@ -0,0 +1,161 @@
+import time
+
+from blueness import module
+from bluer_options import string
+from bluer_options import host
+
+from bluer_sbc import NAME
+from bluer_sbc.hardware.hat.abstract import Abstract_Hat
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+class Prototype_Hat(Abstract_Hat):
+    def __init__(self):
+        super().__init__()
+
+        self.switch_on_time = None
+
+        self.is_jetson = host.is_jetson()
+        self.is_rpi = host.is_rpi()
+
+        if self.is_rpi:
+            import RPi.GPIO as GPIO
+
+            self.switch_pin = 12
+
+            self.green_switch_pin = 16
+            self.red_switch_pin = 13
+
+            self.looper_pin = 22  # red led
+            self.incoming_pin = 18  # yellow led
+            self.data_pin = 36  # green led
+            self.outgoing_pin = 40  # blue led
+
+            self.green_led_pin = 15
+            self.red_led_pin = 7
+
+            GPIO.setmode(GPIO.BOARD)  # numbers GPIOs by physical location
+
+        if self.is_jetson:
+            import Jetson.GPIO as GPIO
+
+            self.switch_pin = 7
+
+            self.trigger_pin = 12
+            self.looper_pin = 29  # red led
+            self.incoming_pin = 31  # yellow led
+            self.data_pin = 32  # green led
+            self.outgoing_pin = 33  # blue led
+
+            GPIO.setmode(GPIO.BOARD)  # numbers GPIOs by physical location
+
+        # http://razzpisampler.oreilly.com/ch07.html
+        for pin in self.input_pins:
+            self.setup(pin, "input", GPIO.PUD_UP)
+
+        for pin in self.output_pins:
+            self.setup(pin, "output")
+            self.output(pin, False)
+
+    def clock(self):
+        super().clock()
+
+        if self.activated(self.switch_pin):
+            if self.switch_on_time is None:
+                self.switch_on_time = time.time()
+                logger.info(f"{NAME}: switch_on_time was set.")
+        else:
+            self.switch_on_time = None
+
+        if self.switch_on_time is not None:
+            self.pulse("outputs")
+
+            if time.time() - self.switch_on_time > 10:
+                self.key_buffer += ["s"]
+
+        return self
+
+    def input(self, pin):
+        if pin == -1:
+            return True
+
+        if self.is_rpi:
+            import RPi.GPIO as GPIO
+        elif self.is_jetson:
+            import Jetson.GPIO as GPIO
+        else:
+            return False
+
+        return GPIO.input(pin) == GPIO.HIGH
+
+    def output(self, pin, output):
+        if pin == -1:
+            return self
+
+        if self.is_rpi:
+            import RPi.GPIO as GPIO
+        elif self.is_jetson:
+            import Jetson.GPIO as GPIO
+        else:
+            return self
+
+        GPIO.output(pin, GPIO.HIGH if output else GPIO.LOW)
+        return self
+
+    def release(self):
+        if self.is_rpi:
+            import RPi.GPIO as GPIO
+        elif self.is_jetson:
+            import Jetson.GPIO as GPIO
+        else:
+            return self
+
+        logger.info(f"{self.__class__.__name__}.release()")
+
+        GPIO.cleanup()
+
+        return self
+
+    def setup(self, pin, what, pull_up_down=None):
+        if pin == -1:
+            return self
+
+        if self.is_rpi:
+            import RPi.GPIO as GPIO
+        elif self.is_jetson:
+            import Jetson.GPIO as GPIO
+        else:
+            return self
+
+        if what == "output":
+            what = GPIO.OUT
+        elif what == "input":
+            what = GPIO.IN
+        else:
+            raise NameError(
+                f"{self.__class__.__name__}.setup({pin}): unknown what: {what}."
+            )
+
+        if pull_up_down is None:
+            GPIO.setup(pin, what)
+        else:
+            GPIO.setup(pin, what, pull_up_down=pull_up_down)
+
+        return self
+
+    def signature(self):
+        return super().signature() + (
+            [
+                "switch:{}".format(
+                    string.pretty_duration(
+                        time.time() - self.switch_on_time,
+                        largest=True,
+                        short=True,
+                    )
+                )
+            ]
+            if self.switch_on_time is not None
+            else []
+        )

bluer_sbc/hardware/screen.py

@@ -0,0 +1,17 @@
+import copy
+
+from bluer_sbc.hardware.hardware import Hardware
+
+
+class Screen(Hardware):
+    def __init__(self):
+        super().__init__()
+        self.size = None
+
+        self.buffer = None
+
+    def update_screen(self, image, session, header):
+        if self.animated:
+            self.buffer = copy.deepcopy(image)
+
+        return super().update_screen(image, session, header)

bluer_sbc/hardware/scroll_phat_hd.py

@@ -0,0 +1,35 @@
+import cv2
+import time
+
+from bluer_sbc.hardware.screen import Screen
+
+
+class Scroll_Phat_HD(Screen):
+    def __init__(self):
+        super(Scroll_Phat_HD, self).__init__()
+        self.size = (7, 17)
+        self.animated = True
+
+    def update_screen(self, image, session, header):
+        import scrollphathd
+
+        image = cv2.resize(
+            image,
+            self.size,
+        )
+
+        super().update_screen(image, session, header)
+
+        image = cv2.cvtColor(
+            image,
+            cv2.COLOR_BGR2GRAY,
+        )
+
+        for y in range(0, 17):
+            for x in range(0, 7):
+                scrollphathd.set_pixel(y, x, image[y, x] / 255.0)
+
+        time.sleep(0.01)
+        scrollphathd.show()
+
+        return self

bluer_sbc/hardware/sparkfun_top_phat/__main__.py

@@ -0,0 +1,51 @@
+import argparse
+import time
+
+from blueness import module
+
+from bluer_sbc import NAME
+from bluer_sbc.hardware.sparkfun_top_phat.classes import Sparkfun_Top_phat
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    default="",
+    help="validate_leds",
+)
+args = parser.parse_args()
+
+hardware = Sparkfun_Top_phat()
+
+success = False
+if args.task == "validate_leds":
+    logger.info("loop started (Ctrl+C to stop)")
+    offset = 0
+    # https://stackoverflow.com/a/18994932/10917551
+    try:
+        while True:
+            for index in range(hardware.pixel_count):
+                hardware.pixels[index] = tuple(
+                    int(thing * hardware.intensity)
+                    for thing in hardware.colormap[
+                        (index + offset) % hardware.pixel_count
+                    ][:3]
+                )
+
+            offset += 1
+
+            hardware.pixels.show()
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        logger.info("Ctrl+C, stopping.")
+    finally:
+        hardware.release()
+    success = True
+else:
+    logger.error(f"-{NAME}: {args.task}: command not found.")
+
+if not success:
+    logger.error(f"-{NAME}: {args.task}: failed.")

bluer_sbc/hardware/sparkfun_top_phat/classes.py

@@ -0,0 +1,104 @@
+import cv2
+import time
+from matplotlib import cm
+
+from blueness import module
+
+from bluer_sbc import NAME
+from bluer_sbc.hardware.screen import Screen
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+class Sparkfun_Top_phat(Screen):
+    def __init__(self):
+        super(Sparkfun_Top_phat, self).__init__()
+        self.size = (7, 17)
+        self.animated = False
+
+        import board
+        import neopixel
+
+        # https://learn.sparkfun.com/tutorials/sparkfun-top-phat-hookup-guide/ws2812b-leds
+        self.pixel_count = 6
+        self.pixels = neopixel.NeoPixel(
+            board.D12,
+            self.pixel_count,
+            auto_write=False,
+        )
+
+        self.intensity = 48
+
+        # https://matplotlib.org/stable/tutorials/colors/colormaps.html
+        self.colormap = cm.get_cmap("copper", self.pixel_count)(range(self.pixel_count))
+
+        self.pulse_cycle = 0
+
+        # https://github.com/sparkfun/Top_pHAT_Button_Py/blob/main/examples/top_phat_button_ex1.py
+        import top_phat_button
+
+        self.buttons = top_phat_button.ToppHATButton()
+        logger.info(f"{NAME}.connection status: {self.buttons.is_connected()}")
+
+        self.buttons.pressed_interrupt_enable = False
+        self.buttons.clicked_interrupt_enable = False
+
+    def clock(self):
+        super().clock()
+
+        self.buttons.button_pressed  # These functions must be called to update button variables to their latest setting
+        self.buttons.button_clicked  # These functions must be called to update button variables to their latest setting
+
+        if self.buttons.a_clicked == True:
+            logger.info(f"{NAME}: a clicked: update.")
+            self.key_buffer += ["u"]
+
+        if self.buttons.b_clicked == True:
+            logger.info(f"{NAME}: b clicked: shutdown.")
+            self.key_buffer += ["s"]
+
+        if self.buttons.center_clicked == True:
+            logger.info(f"{NAME}: center clicked.")
+            self.key_buffer += [" "]
+
+        if self.buttons.up_clicked == True:
+            logger.info(f"{NAME}: up clicked.")
+            self.intensity = min(255, 2 * self.intensity)
+
+        if self.buttons.down_clicked == True:
+            logger.info(f"{NAME}: down clicked.")
+            self.intensity = max(1, self.intensity // 2)
+
+        return self
+
+    def pulse(self, pin=None, frequency=None):
+        super().pulse(pin, frequency)
+
+        for index in range(self.pixel_count):
+            self.pixels[index] = tuple(
+                int(thing * self.intensity)
+                for thing in self.colormap[
+                    (index + int(self.pulse_cycle / 10)) % self.pixel_count
+                ][:3]
+            )
+
+        self.pixels.show()
+
+        self.pulse_cycle += 1
+
+        return self
+
+    def release(self):
+        super().release()
+        for index in range(self.pixel_count):
+            self.pixels[index] = 3 * (0,)
+            self.pixels.show()
+            time.sleep(0.1)
+
+    def update_screen(self, image, session, header):
+        image = cv2.resize(image, self.size)
+
+        super().update_screen(image, session, header)
+
+        return self

bluer_sbc/hardware/unicorn_16x16.py

@@ -0,0 +1,44 @@
+import cv2
+
+from bluer_sbc.hardware.screen import Screen
+
+
+class Unicorn_16x16(Screen):
+    def __init__(self):
+        super().__init__()
+        self.size = (16, 16)
+        self.animated = True
+
+    def release(self):
+        super().release()
+
+        import unicornhathd
+
+        unicornhathd.off()
+
+    def update_screen(self, image, session, header):
+        import unicornhathd
+
+        image = cv2.rotate(
+            cv2.resize(
+                image,
+                self.size,
+            ),
+            cv2.ROTATE_90_CLOCKWISE,
+        )
+
+        super().update_screen(image, session, header)
+
+        for x in range(0, 16):
+            for y in range(0, 16):
+                unicornhathd.set_pixel(
+                    x,
+                    y,
+                    image[x, y, 0],
+                    image[x, y, 1],
+                    image[x, y, 2],
+                )
+
+        unicornhathd.show()
+
+        return self

bluer_sbc/help/__main__.py

@@ -0,0 +1,10 @@
+from blueness import module
+from bluer_options.help.functions import help_main
+
+from bluer_sbc import NAME
+from bluer_sbc.help.functions import help_functions
+
+NAME = module.name(__file__, NAME)
+
+
+help_main(NAME, help_functions)

bluer_sbc/help/adafruit_rgb_matrix.py

@@ -0,0 +1,23 @@
+from typing import List
+
+from blue_options.terminal import show_usage, xtra
+
+
+def help_validate(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "adafruit_rgb_matrix",
+            "validate",
+        ],
+        "validate adafruit_rgb_matrix.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "validate": help_validate,
+}

bluer_sbc/help/camera.py

@@ -0,0 +1,71 @@
+from typing import List
+
+from blue_options.terminal import show_usage
+
+
+def help_capture_image(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "camera",
+            "capture",
+            "image",
+        ],
+        "capture an image.",
+        mono=mono,
+    )
+
+
+def help_capture_video(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    args = [
+        "[--length 10]",
+        "[--preview 1]",
+    ]
+
+    return show_usage(
+        [
+            "@sbc",
+            "camera",
+            "capture",
+            "video",
+        ]
+        + args,
+        "capture a video",
+        mono=mono,
+    )
+
+
+def help_preview(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    args = [
+        "[--length 10]",
+    ]
+
+    return show_usage(
+        [
+            "@sbc",
+            "camera",
+            "preview",
+            "[-]",
+        ]
+        + args,
+        "preview.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "capture": {
+        "image": help_capture_image,
+        "video": help_capture_video,
+    },
+    "preview": help_preview,
+}