bluer-sbc 8.3.1__py3-none-any.whl

bluer_sbc/__init__.py

@@ -0,0 +1,17 @@
+NAME = "bluer_sbc"
+
+ICON = "🌀"
+
+DESCRIPTION = f"{ICON} AI for single board computers."
+
+VERSION = "8.3.1"
+
+REPO_NAME = "bluer-sbc"
+
+MARQUEE = "https://github.com/kamangir/blue-bracket/blob/main/images/helmet-3.jpg"
+
+ALIAS = "@sbc"
+
+
+def fullname() -> str:
+    return f"{NAME}-{VERSION}"

bluer_sbc/__main__.py

@@ -0,0 +1,16 @@
+from blueness.argparse.generic import main
+
+from bluer_sbc import NAME, VERSION, DESCRIPTION, ICON, README
+from bluer_sbc.logger import logger
+
+main(
+    ICON=ICON,
+    NAME=NAME,
+    DESCRIPTION=DESCRIPTION,
+    VERSION=VERSION,
+    main_filename=__file__,
+    tasks={
+        "build_README": lambda _: README.build(),
+    },
+    logger=logger,
+)

bluer_sbc/algo/diff.py

@@ -0,0 +1,81 @@
+import cv2
+import numpy as np
+import time
+
+from blueness import module
+from bluer_options import string
+from bluer_options.logger import crash_report
+
+from bluer_sbc import NAME
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+class Diff:
+    def __init__(self, threshold=0.1):
+        self.size = (60, 80)
+        self.threshold = threshold
+
+        self.last_diff = 0.0
+        self.last_same_period = 0.0
+        self.last_diff_time = time.time()
+
+        self.previous = None
+
+    def same(self, image):
+        if self.threshold < 0:
+            return False
+
+        image_scaled = cv2.resize(image, self.size)
+
+        if self.previous is None:
+            self.previous = image_scaled
+            self.last_diff_time = time.time()
+
+            logger.info(
+                f"{NAME}.diff.same({string.pretty_shape_of_matrix(image)}): initialized."
+            )
+            return False
+
+        try:
+            self.last_diff = float(
+                np.percentile(
+                    np.abs(
+                        image_scaled.astype(np.float) - self.previous.astype(np.float)
+                    ),
+                    90,
+                )
+                / 255
+            )
+            is_same = self.last_diff <= self.threshold
+
+            logger.info(
+                "{}.diff.same({}): {:.03f} - {}{}".format(
+                    NAME,
+                    string.pretty_shape_of_matrix(image),
+                    self.last_diff,
+                    ("!same,same".split(","))[int(is_same)],
+                    " - {} since last diff.".format(
+                        string.pretty_duration(
+                            time.time() - self.last_diff_time,
+                            include_ms=True,
+                            largest=True,
+                            short=True,
+                        )
+                    ),
+                )
+            )
+
+            if not is_same:
+                self.last_same_period = time.time() - self.last_diff_time
+                self.last_diff_time = time.time()
+
+            self.previous = image_scaled
+
+            return is_same
+        except Exception as e:
+            crash_report(e)
+
+        self.previous = None
+        return False

bluer_sbc/config.env

@@ -0,0 +1,30 @@
+BLUER_SBC_CAMERA_HI_RES=1
+BLUER_SBC_CAMERA_WIDTH=728
+BLUER_SBC_CAMERA_HEIGHT=600
+BLUER_SBC_CAMERA_ROTATION=0
+
+BLUER_SBC_DISPLAY_FULLSCREEN=1
+
+BLUER_SBC_HARDWARE_KIND=other
+
+BLUER_SBC_SESSION_OBJECT_TAGS=validation
+
+BLUER_SBC_SESSION_PLUGIN=bluer_sbc
+
+BLUER_SBC_SESSION_IMAGER=other
+
+BLUER_SBC_SESSION_IMAGER_DIFF=0.1
+BLUER_SBC_SESSION_IMAGER_ENABLED=1
+
+BLUER_SBC_SESSION_MONITOR_ENABLED=1
+
+
+BLUER_SBC_SESSION_OUTBOUND_QUEUE=stream
+
+BLUER_SBC_SESSION_AUTO_UPLOAD=1
+
+BLUER_SBC_SESSION_IMAGER_PERIOD=300
+BLUER_SBC_SESSION_MESSENGER_PERIOD=60
+BLUER_SBC_SESSION_REBOOT_PERIOD=14400
+BLUER_SBC_SESSION_SCREEN_PERIOD=4
+BLUER_SBC_SESSION_TEMPERATURE_PERIOD=300

bluer_sbc/env.py

@@ -0,0 +1,35 @@
+from bluer_options.env import load_config, load_env, get_env
+
+load_config(__name__)
+load_env(__name__)
+
+BLUER_SBC_CAMERA_HI_RES = get_env("BLUER_SBC_CAMERA_HI_RES", True)
+BLUER_SBC_CAMERA_WIDTH = get_env("BLUER_SBC_CAMERA_WIDTH", 728)
+BLUER_SBC_CAMERA_HEIGHT = get_env("BLUER_SBC_CAMERA_HEIGHT", 600)
+BLUER_SBC_CAMERA_ROTATION = get_env("BLUER_SBC_CAMERA_ROTATION", 0)
+
+BLUER_SBC_DISPLAY_FULLSCREEN = get_env("BLUER_SBC_DISPLAY_FULLSCREEN", True)
+
+BLUER_SBC_HARDWARE_KIND = get_env("BLUER_SBC_HARDWARE_KIND")
+
+BLUER_SBC_SESSION_PLUGIN = get_env("BLUER_SBC_SESSION_PLUGIN")
+
+BLUER_SBC_SESSION_IMAGER = get_env("BLUER_SBC_SESSION_IMAGER")
+BLUER_SBC_SESSION_IMAGER_DIFF = get_env("BLUER_SBC_SESSION_IMAGER_DIFF", 0.1)
+BLUER_SBC_SESSION_IMAGER_ENABLED = get_env("BLUER_SBC_SESSION_IMAGER_ENABLED", True)
+
+BLUER_SBC_SESSION_MONITOR_ENABLED = get_env("BLUER_SBC_SESSION_MONITOR_ENABLED", True)
+
+BLUER_SBC_SESSION_OBJECT_TAGS = get_env("BLUER_SBC_SESSION_OBJECT_TAGS")
+
+BLUER_SBC_SESSION_OUTBOUND_QUEUE = get_env("BLUER_SBC_SESSION_OUTBOUND_QUEUE")
+
+BLUER_SBC_SESSION_AUTO_UPLOAD = get_env("BLUER_SBC_SESSION_AUTO_UPLOAD", True)
+
+BLUER_SBC_SESSION_IMAGER_PERIOD = get_env("BLUER_SBC_SESSION_IMAGER_PERIOD", 300)
+BLUER_SBC_SESSION_MESSENGER_PERIOD = get_env("BLUER_SBC_SESSION_MESSENGER_PERIOD", 60)
+BLUER_SBC_SESSION_REBOOT_PERIOD = get_env("BLUER_SBC_SESSION_REBOOT_PERIOD", 14400)
+BLUER_SBC_SESSION_SCREEN_PERIOD = get_env("BLUER_SBC_SESSION_SCREEN_PERIOD", 4)
+BLUER_SBC_SESSION_TEMPERATURE_PERIOD = get_env(
+    "BLUER_SBC_SESSION_TEMPERATURE_PERIOD", 300
+)

bluer_sbc/hardware/__init__.py

@@ -0,0 +1,38 @@
+from blueness import module
+from bluer_options import host
+
+from bluer_sbc import NAME
+from bluer_sbc.env import BLUER_SBC_HARDWARE_KIND
+from bluer_sbc.hardware.hardware import Hardware as Hardware_Class
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+if host.is_mac():
+    from bluer_sbc.hardware.display import Display as Hardware_Class
+elif BLUER_SBC_HARDWARE_KIND == "adafruit_rgb_matrix":
+    from bluer_sbc.hardware.adafruit_rgb_matrix import (
+        Adafruit_Rgb_Matrix as Hardware_Class,
+    )
+elif BLUER_SBC_HARDWARE_KIND == "grove":
+    from bluer_sbc.hardware.grove import Grove as Hardware_Class
+elif BLUER_SBC_HARDWARE_KIND == "prototype_hat":
+    if host.is_headless():
+        from bluer_sbc.hardware.hat.prototype import Prototype_Hat as Hardware_Class
+    else:
+        from bluer_sbc.hardware.display import Display as Hardware_Class
+elif BLUER_SBC_HARDWARE_KIND == "scroll_phat_hd":
+    from bluer_sbc.hardware.scroll_phat_hd import Scroll_Phat_HD as Hardware_Class
+elif BLUER_SBC_HARDWARE_KIND == "sparkfun-top-phat":
+    from bluer_sbc.hardware.sparkfun_top_phat.classes import (
+        Sparkfun_Top_phat as Hardware_Class,
+    )
+elif BLUER_SBC_HARDWARE_KIND == "unicorn_16x16":
+    from bluer_sbc.hardware.unicorn_16x16 import Unicorn_16x16 as Hardware_Class
+else:
+    raise NameError(f"bluer-sbc: {BLUER_SBC_HARDWARE_KIND}: hardware not found.")
+
+hardware = Hardware_Class()
+
+logger.info(f"{NAME}: {BLUER_SBC_HARDWARE_KIND}: {hardware.__class__.__name__}")

bluer_sbc/hardware/adafruit_rgb_matrix.py

@@ -0,0 +1,30 @@
+import cv2
+from PIL import Image
+
+from bluer_sbc.hardware.screen import Screen
+
+
+class Adafruit_Rgb_Matrix(Screen):
+    def __init__(self):
+        super(Adafruit_Rgb_Matrix, self).__init__()
+        self.size = (32, 32)
+        self.animated = True
+
+        from rgbmatrix import RGBMatrix, RGBMatrixOptions
+
+        options = RGBMatrixOptions()
+        options.rows = 32
+        options.chain_length = 1
+        options.parallel = 1
+        options.hardware_mapping = "adafruit-hat"  # adafruit-hat/regular
+
+        self.matrix = RGBMatrix(options=options)
+
+    def update_screen(self, image, session, header):
+        image = cv2.resize(image, self.size)
+
+        super().update_screen(image, session, header)
+
+        self.matrix.SetImage(Image.fromarray(image).convert("RGB"))
+
+        return self

bluer_sbc/hardware/display.py

@@ -0,0 +1,112 @@
+import cv2
+import numpy as np
+
+from blueness import module
+from bluer_options.logger import crash_report
+from bluer_options.host import is_mac
+from bluer_objects import file
+from bluer_objects.graphics import add_signature
+from bluer_objects.graphics.screen import get_size
+
+from bluer_sbc import NAME
+from bluer_sbc import env
+from bluer_sbc.hardware.hat.prototype import Prototype_Hat
+from bluer_sbc.host import signature
+from bluer_sbc.logger import logger
+
+
+NAME = module.name(__file__, NAME)
+
+
+class Display(Prototype_Hat):
+    def __init__(self):
+        super().__init__()
+
+        self.canvas = None
+        self.canvas_size = (640, 480)
+
+        self.title = " | ".join(signature())
+
+        self.created = False
+
+        self.sign_images = True
+        self.interpolation = cv2.INTER_LINEAR
+
+    def create(self):
+        if self.created:
+            return
+        self.created = True
+
+        logger.info(f"{NAME}.create()")
+
+        if env.BLUER_SBC_DISPLAY_FULLSCREEN and not is_mac():
+            # https://stackoverflow.com/a/34337534
+            cv2.namedWindow(self.title, cv2.WND_PROP_FULLSCREEN)
+            cv2.setWindowProperty(
+                self.title, cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN
+            )
+
+            screen_height, screen_width = get_size()
+            self.canvas_size = (
+                screen_width,
+                screen_height,
+            )
+        else:
+            cv2.namedWindow(self.title, cv2.WINDOW_NORMAL)
+            cv2.resizeWindow(
+                self.title,
+                self.canvas_size[0],
+                self.canvas_size[1],
+            )
+
+    def save(self, filename: str = "") -> str:
+        if self.canvas is None:
+            return ""
+
+        if not filename:
+            filename = file.auxiliary("display", "jpg")
+
+        return filename if file.save_image(filename, self.canvas) else ""
+
+    def update_gui(self):
+        try:
+            if len(self.canvas.shape) == 2:
+                self.canvas = np.stack(3 * [self.canvas], axis=2)
+
+            cv2.imshow(
+                self.title,
+                cv2.cvtColor(
+                    cv2.resize(
+                        self.canvas,
+                        dsize=self.canvas_size,
+                        interpolation=self.interpolation,
+                    ),
+                    cv2.COLOR_BGR2RGB,
+                ),
+            )
+        except Exception as e:
+            crash_report(e)
+
+    def update_screen(self, image, session, header):
+        super().update_screen(image, session, header)
+
+        self.canvas = np.copy(image)
+
+        if self.sign_images:
+            self.canvas = add_signature(
+                self.canvas,
+                header=header,
+                footer=[" | ".join(signature())],
+            )
+
+        self.create()
+
+        self.update_gui()
+
+        key = cv2.waitKey(1)
+        if key not in [-1, 255]:
+            key = chr(key).lower()
+            logger.info(f"{NAME}.update_screen(): key: '{key}'")
+            self.key_buffer.append(key)
+
+        return self

bluer_sbc/hardware/grove.py

@@ -0,0 +1,104 @@
+from PIL import Image
+from PIL import ImageDraw
+from PIL import ImageFont
+
+from bluer_options import string
+
+from bluer_sbc.hardware.screen import Screen
+from bluer_sbc.logger import logger
+
+BUTTON = 24
+
+RST = None  # on the PiOLED this pin isnt used
+
+
+class Grove(Screen):
+    def __init__(self):
+        super(Grove, self).__init__()
+
+        from grove.grove_button import GroveButton
+
+        # https://wiki.seeedstudio.com/Grove-OLED_Display_0.96inch/
+        self.size = (64, 128)
+
+        self.button = GroveButton(BUTTON)
+        self.button.on_press = lambda t: grove_button_on_press(self, t)
+        self.button.on_release = lambda t: grove_button_on_release(self, t)
+
+        import Adafruit_SSD1306
+
+        # https://github.com/IcingTomato/Seeed_Python_SSD1315/blob/master/examples/stats.py
+        self.display = Adafruit_SSD1306.SSD1306_128_64(rst=RST)
+
+        self.display.begin()
+        self.display.clear()
+        self.display.display()
+
+        self.image = Image.new(
+            "1",
+            (self.display.width, self.display.height),
+        )
+
+        self.draw = ImageDraw.Draw(self.image)
+
+        # Draw a black filled box to clear the image.
+        self.draw.rectangle(
+            (0, 0, self.display.width, self.display.height),
+            outline=0,
+            fill=0,
+        )
+
+        self.padding = -2
+        self.top = self.padding
+        self.bottom = self.display.height - self.padding
+
+        self.font = ImageFont.load_default()
+
+        self.line_count = 8
+        self.line_length = 21
+
+    def update_screen(self, image, session, header):
+        super().update_screen(image, session, header)
+
+        signature = (" | ".join(session.signature())).split(" | ")
+
+        self.draw.rectangle(
+            (0, 0, self.display.width, self.display.height),
+            outline=0,
+            fill=0,
+        )
+
+        for row in range(min(len(signature), self.line_count)):
+            self.draw.text(
+                (0, self.top + 8 * row),
+                signature[row],
+                font=self.font,
+                fill=255,
+            )
+
+        self.display.image(self.image)
+        self.display.display()
+
+        return self
+
+
+def grove_button_on_press(screen: Screen, t):
+    logger.info("grove.button: pressed.")
+
+
+def grove_button_on_release(screen: Screen, t):
+    logger.info(f"grove.button: released after {string.pretty_duration(t)}.")
+
+    if t > 60:
+        logger.info("long press, ignored.")
+        return
+
+    if t > 5:
+        key = "s"
+    elif t > 3:
+        key = "u"
+    else:
+        key = " "
+
+    screen.key_buffer.append(key)
+    logger.info(f"{screen.__class__.__name__}: '{key}'")

bluer_sbc/hardware/hardware.py

@@ -0,0 +1,58 @@
+import random
+
+from bluer_sbc import fullname
+from bluer_sbc.logger import logger
+
+
+class Hardware:
+    def __init__(self):
+        logger.info(f"{self.__class__.__name__}.init().")
+
+        self.key_buffer = []
+        self.animated = False
+
+    def animate(self):
+        if self.buffer is None:
+            return self
+        if not self.animated:
+            return self
+
+        y = random.randint(0, self.buffer.shape[0] - 1)
+        x = random.randint(0, self.buffer.shape[1] - 1)
+
+        self.buffer[y, x] = 255 - self.buffer[y, x]
+
+        self.animated = False
+        self.update_screen(self.buffer, None, [], [])
+        self.animated = True
+
+    def clock(self):
+        return self
+
+    def pressed(self, keys):
+        output = bool([key for key in keys if key in self.key_buffer])
+
+        self.key_buffer = [key for key in self.key_buffer if key not in keys]
+
+        return output
+
+    def pulse(self, pin=None, frequency=None):
+        """
+        pulse pin.
+        :param pin: "data" / "incoming" / "loop" / "outputs"
+        :param frequency: frequency
+        :return: self
+        """
+        return self
+
+    def release(self):
+        logger.info(f"{self.__class__.__name__}.release()")
+
+    def signature(self):
+        return [
+            fullname(),
+            f"hardware:{self.__class__.__name__}",
+        ]
+
+    def update_screen(self, image, session, header):
+        return self

bluer_sbc/hardware/hat/__main__.py

@@ -0,0 +1,91 @@
+import argparse
+import time
+
+from blueness import module
+from bluer_options import string
+
+from bluer_sbc import NAME
+from bluer_sbc.hardware.hat.prototype import Prototype_Hat
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    default="",
+    help="input/output",
+)
+parser.add_argument(
+    "--outputs",
+    type=str,
+    default="",
+)
+args = parser.parse_args()
+
+hardware = Prototype_Hat()
+
+success = False
+if args.task == "input":
+    logger.info("loop started (Ctrl+C to stop)")
+    # https://stackoverflow.com/a/18994932/10917551
+    try:
+        while True:
+            logger.info(
+                "inputs: {}".format(
+                    ", ".join([str(hardware.input(pin)) for pin in hardware.input_pins])
+                )
+            )
+            time.sleep(0.1)
+    except KeyboardInterrupt:
+        logger.info("Ctrl+C, stopping.")
+    finally:
+        hardware.release()
+    success = True
+elif args.task == "output":
+    outputs = args.outputs + len(hardware.output_pins) * "1"
+    for index, pin in enumerate(hardware.output_pins):
+        hardware.output(pin, outputs[index] == "1")
+    hardware.release()
+    success = True
+elif args.task == "validate":
+    logger.info("loop started (Ctrl+C to stop)")
+    value = True
+    try:
+        while True:
+            activity = False
+            for pin, pin_name in zip(
+                [
+                    hardware.green_switch_pin,
+                    hardware.red_switch_pin,
+                    hardware.switch_pin,
+                    hardware.trigger_pin,
+                ],
+                "green_switch_pin,red_switch_pin,switch_pin,trigger_pin".split(","),
+            ):
+                if hardware.activated(pin):
+                    logger.info(
+                        "{}: {} activated.".format(
+                            string.timestamp(ms=True),
+                            pin_name,
+                        )
+                    )
+                    activity = True
+
+            for pin in hardware.output_pins:
+                hardware.output(pin, activity or value)
+            time.sleep(0.1)
+
+            value = not value
+    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.")