bluer-sbc 8.3.1__py3-none-any.whl

bluer_sbc/help/functions.py

@@ -0,0 +1,52 @@
+from typing import List
+
+from bluer_options.terminal import show_usage
+from bluer_ai.help.generic import help_functions as generic_help_functions
+
+from bluer_sbc.help.adafruit_rgb_matrix import (
+    help_functions as help_adafruit_rgb_matrix,
+)
+from bluer_sbc.help.camera import help_functions as help_camera
+from bluer_sbc.help.grove import help_functions as help_grove
+from bluer_sbc.help.hat import help_functions as help_hat
+from bluer_sbc.help.lepton import help_functions as help_lepton
+from bluer_sbc.help.scroll_phat_hd import help_functions as help_scroll_phat_hd
+from bluer_sbc.help.sparkfun_top_phat import help_functions as help_sparkfun_top_phat
+from bluer_sbc.help.session import help_functions as help_session
+from bluer_sbc.help.unicorn_16x16 import help_functions as help_unicorn_16x16
+from bluer_sbc import ALIAS
+
+
+def help_browse(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = "actions|repo"
+
+    return show_usage(
+        [
+            "@plugin",
+            "browse",
+            f"[{options}]",
+        ],
+        "browse bluer_sbc.",
+        mono=mono,
+    )
+
+
+help_functions = generic_help_functions(plugin_name=ALIAS)
+
+help_functions.update(
+    {
+        "adafruit_rgb_matrix": help_adafruit_rgb_matrix,
+        "browse": help_browse,
+        "camera": help_camera,
+        "grove": help_grove,
+        "hat": help_hat,
+        "lepton": help_lepton,
+        "scroll_phat_hd": help_scroll_phat_hd,
+        "session": help_session,
+        "sparkfun_top_phat": help_sparkfun_top_phat,
+        "unicorn_16x16": help_unicorn_16x16,
+    }
+)

bluer_sbc/help/grove.py

@@ -0,0 +1,59 @@
+from typing import List
+
+from blue_options.terminal import show_usage
+
+
+def help_info(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "grove",
+            "info",
+        ],
+        "show grove info.",
+        mono=mono,
+    )
+
+
+def help_validate(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = "adc | button"
+
+    return show_usage(
+        [
+            "grove",
+            "validate",
+            f"[{options}]",
+        ],
+        "validate grove.",
+        mono=mono,
+    )
+
+
+def help_validate_oled_128x64(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = "animate | buttons | image | shapes | stats"
+
+    return show_usage(
+        [
+            "grove",
+            "validate",
+            "oled_128x64",
+            f"[{options}]",
+        ],
+        "validate grove oled_128x64.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "info": help_info,
+    "validate": help_validate,
+    "validate_oled_128x64": help_validate_oled_128x64,
+}

bluer_sbc/help/hat.py

@@ -0,0 +1,56 @@
+from typing import List
+
+from blue_options.terminal import show_usage
+
+
+def help_input(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "hat",
+            "input",
+        ],
+        "read hat inputs.",
+        mono=mono,
+    )
+
+
+def help_output(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "hat",
+            "output",
+            "<10101010>",
+        ],
+        "activate hat outputs.",
+        mono=mono,
+    )
+
+
+def help_validate(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "hat",
+            "validate",
+        ],
+        "validate hat.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "input": help_input,
+    "output": help_output,
+    "validate": help_validate,
+}

bluer_sbc/help/lepton.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from blue_options.terminal import show_usage, xtra
+
+
+def help_capture(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "lepton",
+            "capture",
+        ],
+        "lepton.capture.",
+        mono=mono,
+    )
+
+
+def help_preview(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    return show_usage(
+        [
+            "@sbc",
+            "lepton",
+            "preview",
+        ],
+        "lepton.preview.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "capture": help_capture,
+    "preview": help_preview,
+}

bluer_sbc/help/scroll_phat_hd.py

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

bluer_sbc/help/session.py

@@ -0,0 +1,26 @@
+from typing import List
+
+from blue_options.terminal import show_usage, xtra
+
+
+def help_session_start(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = xtra("dryrun,sudo,~upload", mono=mono)
+
+    return show_usage(
+        [
+            "@sbc",
+            "session",
+            "start",
+            f"[{options}]",
+        ],
+        "start an @sbc session.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "start": help_session_start,
+}

bluer_sbc/help/sparkfun_top_phat.py

@@ -0,0 +1,26 @@
+from typing import List
+
+from blue_options.terminal import show_usage, xtra
+
+
+def help_validate(
+    tokens: List[str],
+    mono: bool,
+) -> str:
+    options = "button | leds"
+
+    return show_usage(
+        [
+            "@sbc",
+            "sparkfun_top_phat",
+            "validate",
+            f"[{options}]",
+        ],
+        "validate sparkfun_top_phat.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "validate": help_validate,
+}

bluer_sbc/help/unicorn_16x16.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",
+            "unicorn_16x16",
+            "validate",
+        ],
+        "validate unicorn_16x16.",
+        mono=mono,
+    )
+
+
+help_functions = {
+    "validate": help_validate,
+}

bluer_sbc/host.py

@@ -0,0 +1,11 @@
+from typing import List
+
+from bluer_ai.host import signature as abcli_signature
+
+from bluer_sbc import fullname
+
+
+def signature() -> List[str]:
+    return [
+        fullname(),
+    ] + abcli_signature()

bluer_sbc/imager/__init__.py

@@ -0,0 +1,16 @@
+from blueness import module
+
+from bluer_sbc import NAME
+from bluer_sbc import env
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+imager_name = env.BLUER_SBC_SESSION_IMAGER
+if imager_name == "lepton":
+    from bluer_sbc.imager.lepton import instance as imager
+else:
+    from bluer_sbc.imager.camera import instance as imager
+
+logger.info(f"{NAME}: {imager_name}: {imager.__class__.__name__}")

bluer_sbc/imager/camera/__init__.py

@@ -0,0 +1,3 @@
+from bluer_sbc.imager.camera.classes import Camera
+
+instance = Camera()

bluer_sbc/imager/camera/__main__.py

@@ -0,0 +1,69 @@
+import argparse
+
+from blueness import module
+from bluer_options import string
+from bluer_objects.env import abcli_object_name
+
+from bluer_sbc import NAME
+from bluer_sbc.imager.camera import instance as camera
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+parser = argparse.ArgumentParser(NAME)
+parser.add_argument(
+    "task",
+    type=str,
+    help="capture | capture_video | preview",
+)
+parser.add_argument(
+    "--object_name",
+    type=str,
+    default=abcli_object_name,
+)
+parser.add_argument(
+    "--filename",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--length",
+    type=int,
+    default=0,
+)
+parser.add_argument(
+    "--output_path",
+    type=str,
+    default="",
+)
+parser.add_argument(
+    "--preview",
+    type=int,
+    default=1,
+    help="0 | 1",
+)
+args = parser.parse_args()
+
+success = False
+if args.task == "capture":
+    success, image = camera.capture(
+        filename=args.filename if args.filename else f"{string.timestamp()}.png",
+        object_name=args.object_name,
+    )
+elif args.task == "capture_video":
+    success = camera.capture_video(
+        filename=args.filename if args.filename else f"{string.timestamp()}.h264",
+        object_name=args.object_name,
+        length=args.length if args.length else 10,
+        preview=args.preview,
+        resolution=(728, 600),
+    )
+elif args.task == "preview":
+    success = camera.preview(length=args.length if args.length else -1)
+
+else:
+    logger.error(f"-{NAME}: {args.task}: command not found.")
+
+if not success:
+    logger.error(f"-{NAME}: {args.task}: failed.")

bluer_sbc/imager/camera/classes.py

@@ -0,0 +1,259 @@
+import cv2
+from typing import Tuple
+import numpy as np
+from time import sleep
+
+from blueness import module
+from blue_options import string
+from blue_options import host
+from bluer_options.timer import Timer
+from bluer_options.logger import crash_report
+from bluer_objects import file, objects
+
+from bluer_sbc import env
+from bluer_sbc import NAME
+from bluer_sbc.hardware import hardware
+from bluer_sbc.imager.classes import Imager
+from bluer_sbc.logger import logger
+
+NAME = module.name(__file__, NAME)
+
+
+class Camera(Imager):
+    def __init__(self):
+        self.device = None
+        self.resolution = []
+
+    def capture(
+        self,
+        close_after: bool = True,
+        log: bool = True,
+        open_before: bool = True,
+        filename: str = "",
+        object_name: str = "",
+    ) -> Tuple[bool, np.ndarray]:
+        success = False
+        image = np.ones((1, 1, 3), dtype=np.uint8) * 127
+
+        if open_before:
+            if not self.open():
+                return success, image
+
+        if self.device is None:
+            return success, image
+
+        if host.is_rpi():
+            temp = file.auxiliary("camera", "png")
+            try:
+                self.device.capture(temp)
+                success = True
+            except Exception as e:
+                crash_report(e)
+
+            if success:
+                success, image = file.load_image(temp)
+        else:
+            try:
+                success, image = self.device.read()
+
+                if success:
+                    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+            except Exception as e:
+                crash_report(e)
+
+        if close_after:
+            self.close()
+
+        if success and log:
+            logger.info(f"{NAME}.capture(): {string.pretty_shape_of_matrix(image)}")
+
+        if success and filename:
+            success = file.save_image(
+                filename=objects.path_of(
+                    object_name=object_name,
+                    filename=filename,
+                ),
+                image=image,
+                log=log,
+            )
+
+        return success, image
+
+    # https://projects.raspberrypi.org/en/projects/getting-started-with-picamera/6
+    def capture_video(
+        self,
+        filename: str,
+        object_name: str,
+        length: int = 10,  # in seconds
+        preview: bool = True,
+        pulse: bool = True,
+        resolution=None,
+    ) -> bool:
+        if not host.is_rpi():
+            logger.error(f"{NAME}.capture_video() only works on rpi.")
+            return False
+
+        if not self.open(resolution=resolution):
+            return False
+
+        full_filename = objects.path_of(
+            object_name=object_name,
+            filename=filename,
+        )
+
+        success = True
+        try:
+            if preview:
+                self.device.start_preview()
+
+            self.device.start_recording(full_filename)
+            if pulse:
+                for _ in range(int(10 * length)):
+                    hardware.pulse("outputs")
+                    sleep(0.1)
+            else:
+                sleep(length)
+            self.device.stop_recording()
+
+            if preview:
+                self.device.stop_preview()
+        except Exception as e:
+            crash_report(e)
+            success = False
+
+        if not self.close():
+            return False
+
+        if success:
+            logger.info(
+                "{}.capture_video(): {} -{}-> {}".format(
+                    NAME,
+                    string.pretty_duration(length),
+                    string.pretty_bytes(file.size(full_filename)),
+                    filename,
+                )
+            )
+
+        return success
+
+    def close(self, log: bool = True) -> bool:
+        if self.device is None:
+            logger.warning(f"{NAME}.close(): device is {self.device}, failed.")
+            return False
+
+        success = False
+        try:
+            if host.is_rpi():
+                self.device.close()
+            else:
+                self.device.release()
+            success = True
+        except Exception as e:
+            crash_report(e)
+            return False
+
+        self.device = None
+
+        if log:
+            logger.info(f"{NAME}.close().")
+
+        return success
+
+    def get_resolution(self):
+        try:
+            if host.is_rpi():
+                from picamera import PiCamera
+
+                return [value for value in self.device.resolution]
+            else:
+                return [
+                    int(self.device.get(const))
+                    for const in [cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FRAME_WIDTH]
+                ]
+        except Exception as e:
+            crash_report(e)
+            return []
+
+    def open(
+        self,
+        log: bool = True,
+        resolution=None,
+    ) -> bool:
+        try:
+            if host.is_rpi():
+                from picamera import PiCamera
+
+                self.device = PiCamera()
+                self.device.rotation = env.BLUER_SBC_CAMERA_ROTATION
+
+                # https://projects.raspberrypi.org/en/projects/getting-started-with-picamera/7
+                self.device.resolution = (
+                    (
+                        (2592, 1944)
+                        if env.BLUER_SBC_CAMERA_HI_RES
+                        else (
+                            env.BLUER_SBC_CAMERA_WIDTH,
+                            env.BLUER_SBC_CAMERA_HEIGHT,
+                        )
+                    )
+                    if resolution is None
+                    else resolution
+                )
+            else:
+                self.device = cv2.VideoCapture(0)
+
+                # https://stackoverflow.com/a/31464688
+                self.device.set(cv2.CAP_PROP_FRAME_WIDTH, 10000)
+                self.device.set(cv2.CAP_PROP_FRAME_HEIGHT, 10000)
+
+            self.resolution = self.get_resolution()
+
+            if log:
+                logger.info(f"{NAME}.open({string.pretty_shape(self.resolution)})")
+
+            return True
+        except Exception as e:
+            crash_report(e)
+            return False
+
+    def preview(
+        self,
+        length: float = -1,
+    ) -> bool:
+        logger.info(
+            "{}.preview{} ... | press q or e to quit ...".format(
+                NAME,
+                "[{}]".format("" if length == -1 else string.pretty_duration(length)),
+            )
+        )
+
+        hardware.sign_images = False
+        timer = Timer(length, "preview")
+        try:
+            self.open(
+                log=True,
+                resolution=(320, 240),
+            )
+
+            while not hardware.pressed("qe"):
+                _, image = self.capture(
+                    close_after=False,
+                    log=False,
+                    open_before=False,
+                )
+                hardware.update_screen(image, None, [])
+
+                if timer.tick(wait=True):
+                    logger.info(
+                        "{} is up, quitting.".format(string.pretty_duration(length))
+                    )
+                    break
+
+        except KeyboardInterrupt:
+            logger.info("Ctrl+C, stopping.")
+
+        finally:
+            self.close(log=True)
+
+        return True

bluer_sbc/imager/camera/constants.py

@@ -0,0 +1,30 @@
+specifications = {
+    "rpi-ir": {
+        "height": 1944,
+        "width": 2592,
+        "diagonal": 3240,
+        "fov": {
+            "diagonal": 80,
+            "horizontal": 64,
+            "vertical": 48,
+        },
+    },
+    "rpi-noir": {
+        "height": 1944,
+        "width": 2592,
+        "diagonal": 3240,
+        "fov": {
+            "horizontal": 62.2,
+            "vertical": 48.8,
+        },
+    },
+    "rpi-rgb": {
+        "height": 1944,
+        "width": 2592,
+        "diagonal": 3240,
+        "fov": {
+            "horizontal": 62.2,
+            "vertical": 48.8,
+        },
+    },
+}