aether-robotics 3.2.0__tar.gz → 3.2.3__tar.gz

{aether_robotics-3.2.0/aether_robotics.egg-info → aether_robotics-3.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.2.0
+Version: 3.2.3
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

aether_robotics-3.2.3/VERSION

@@ -0,0 +1 @@
+3.2.3

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "3.2.0"
+__version__ = "3.2.3"
 __author__ = "Chahel Paatur"

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/app.py

@@ -468,6 +468,15 @@ def run_agent(args) -> None:
     built_tools = builder.build_all()
     _print_activity("TOOLS", builder.build_summary())
 
+    # OLED startup animation (only on Pi with real hardware attached)
+    oled_tool = built_tools.get("oled")
+    if oled_tool is not None and getattr(oled_tool, "mode", "sim") == "real":
+        try:
+            oled_tool.show_startup()
+            _print_activity("OLED", "Startup animation played on hardware")
+        except Exception as e:
+            _print_activity("OLED", f"startup animation failed: {e}")
+
     nav_engine = NavigationEngine(discovery.manifest, tools=built_tools)
     nav_actions = nav_engine.available_actions()
     _print_activity("NAV", f"Level {nav_engine.level} ({nav_engine.level_name}) — "
@@ -621,6 +630,12 @@ def run_agent(args) -> None:
         if hints:
             _print_activity("MEM", "Found similar past objectives")
 
+        if oled_tool is not None:
+            try:
+                oled_tool.draw_face("thinking")
+            except Exception:
+                pass
+
         if llm_planner.available:
             _print_activity("PLAN", "Sending to LLM planner...")
             # Prepend planning hints to memory context
@@ -714,6 +729,11 @@ def run_agent(args) -> None:
             if not result.success:
                 step_faults += 1
                 faults_detected += 1
+                if oled_tool is not None:
+                    try:
+                        oled_tool.draw_face("alert")
+                    except Exception:
+                        pass
                 _print_fault_alert("TASK_FAILURE",
                                    f"{tool_name} failed: {result.error} "
                                    f"({result.duration_ms:.0f}ms)")
@@ -728,6 +748,11 @@ def run_agent(args) -> None:
                     sim_accumulator.append(("timeout", params.get("scenario", "?"), result.output))
                 prev_output = result.output
             else:
+                if oled_tool is not None:
+                    try:
+                        oled_tool.draw_face("speaking")
+                    except Exception:
+                        pass
                 summary = _summarize_output(result.output)
                 label = "KNOWLEDGE" if (tool_name == "web_search"
                                         and str(result.output).startswith("[KNOWLEDGE]")) else "OK"
@@ -778,6 +803,19 @@ def run_agent(args) -> None:
 
         # Episode summary
         outcome = "SUCCESS" if step_faults == 0 else "DEGRADED"
+
+        # Auto-expression on OLED: happy on success, alert on faults
+        if oled_tool is not None:
+            try:
+                if step_faults == 0:
+                    oled_tool.draw_face("happy")
+                    time.sleep(0.5)
+                    oled_tool.draw_face("neutral")
+                else:
+                    oled_tool.draw_face("alert")
+            except Exception:
+                pass
+
         print(f"\n  --- Objective Complete ---")
         print(f"  Actions:  {len(plan)}")
         print(f"  Faults:   {step_faults}")

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/core/auto_installer.py

@@ -32,6 +32,7 @@ INSTALL_MAP = {
     "anthropic": "anthropic",
     "psutil": "psutil",
     "PIL": "Pillow",
+    "luma.oled": "luma.oled",
 }
 
 # What each library enables
@@ -52,6 +53,7 @@ CAPABILITY_MAP = {
     "anthropic": "Anthropic API (LLM planner)",
     "psutil": "system monitoring",
     "PIL": "image processing",
+    "luma.oled": "SSD1306 OLED display output",
 }
 
 
@@ -116,6 +118,57 @@ class AutoInstaller:
                 pass
         return int(installed / total * 100) if total > 0 else 0
 
+    def _auto_install_oled(self) -> bool:
+        """Auto-install OLED libraries when SPI device detected but luma.oled missing.
+
+        Called before the general install prompt. When the Pi has
+        /dev/spidev0.x it means the user configured SPI for a display,
+        so we install without asking.
+
+        Returns True if anything was installed.
+        """
+        hw = self._manifest.get("hardware", {})
+        oled = hw.get("oled", {})
+        if not oled.get("spi_ready") or oled.get("available"):
+            return False
+
+        # luma.oled not importable — install it
+        try:
+            importlib.import_module("luma.oled")
+            return False  # already importable
+        except ImportError:
+            pass
+
+        print("[AutoInstaller] SPI device detected — installing OLED libraries...")
+
+        # apt dependencies (best-effort, may need sudo)
+        if self._is_linux:
+            apt_pkgs = ["python3-pil", "python3-dev", "python3-smbus",
+                        "libfreetype6-dev", "libjpeg-dev", "libopenjp2-7"]
+            try:
+                print(f"  Installing: {', '.join(apt_pkgs)} (apt)...",
+                      end=" ", flush=True)
+                subprocess.run(
+                    ["sudo", "apt-get", "install", "-y"] + apt_pkgs,
+                    capture_output=True, text=True, timeout=120)
+                print("OK")
+            except (subprocess.TimeoutExpired, OSError, FileNotFoundError):
+                print("SKIPPED (sudo not available)")
+
+        # pip install luma.oled (pulls Pillow as dependency)
+        installed = False
+        for pkg in ("luma.oled", "Pillow"):
+            print(f"  Installing: {pkg} (pip)...", end=" ", flush=True)
+            if self._pip_install(pkg):
+                print("OK")
+                installed = True
+            else:
+                print("FAILED")
+
+        if installed:
+            print("[AutoInstaller] OLED display ready")
+        return installed
+
     def run(self, auto_install: bool = False, no_install: bool = False) -> bool:
         """Run the auto-installer flow.
 
@@ -127,8 +180,11 @@ class AutoInstaller:
         Returns:
             True if any packages were installed.
         """
+        # Auto-install OLED libs when SPI is ready (always, before skip check)
+        oled_installed = self._auto_install_oled()
+
         if no_install or self._skip_session or _load_skip_pref():
-            return False
+            return oled_installed
 
         missing = self.check_missing()
         if not missing:

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/core/llm_planner.py

@@ -52,6 +52,15 @@ _SYSTEM_PROMPT = (
     "motor or flight actions at a lower level.\n"
     "- Navigation action inputs use: color, direction, speed, altitude, pin, "
     "duration, timeout, marker_color, left_pin, right_pin, lat, lon, alt\n"
+    "- If an OLED display is available (display_text, draw_face, etc. appear "
+    "in available_tools), use display_text or draw_face to show results on "
+    "screen in addition to returning text. For finger counting: chain "
+    "capture_image → count_fingers → show_value(label=\"Fingers\", value=N). "
+    "For weather/news: chain web_search → display_text. For expressions: use "
+    "draw_face with an appropriate expression ('happy', 'thinking', 'alert', "
+    "'sleeping', 'speaking'). OLED action inputs use: text, font_size, x, y, "
+    "clear, label, value, unit, expression, state, times, duration, speed, "
+    "image_path, frames, fps.\n"
     "- Return valid JSON only — an object with a single key 'steps' containing "
     "the array. No markdown, no explanation, no code fences."
 )

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/core/navigation_engine.py

@@ -1426,6 +1426,13 @@ _IMU_ACTIONS = [
     "get_orientation", "detect_vibration",
 ]
 
+# OLED display actions (added when OLED hardware detected)
+_OLED_ACTIONS = [
+    "display_text", "display_image", "clear_oled", "show_animation",
+    "draw_face", "draw_eyes", "animate_blink", "animate_speaking",
+    "scroll_text", "show_value", "show_startup",
+]
+
 
 class NavigationEngine:
     """
@@ -1513,11 +1520,20 @@ class NavigationEngine:
         actions = list(_SYSTEM_ACTIONS)
         if self._imu.available:
             actions.extend(_IMU_ACTIONS)
+        if self._has_oled():
+            actions.extend(_OLED_ACTIONS)
         for lvl in range(1, self._level + 1):
             actions.extend(_LEVEL_ACTIONS.get(lvl, []))
         actions.append("observe")
         return sorted(set(actions))
 
+    def _has_oled(self) -> bool:
+        hw_oled = self._manifest.get("hardware", {}).get("oled", {})
+        if hw_oled.get("available"):
+            return True
+        # sim-mode OLEDTool built when PIL is installed
+        return "oled" in self._tools
+
     def execute(self, action: str, params: Optional[Dict] = None):
         """Execute a navigation action by name.
 
@@ -1601,6 +1617,17 @@ class NavigationEngine:
             if action in yolo_map:
                 return yolo_map[action]()
 
+        # OLED actions (level 1+ when oled tool available)
+        oled = self._tools.get("oled")
+        if oled and action in _OLED_ACTIONS:
+            fn = getattr(oled, action, None)
+            if fn is not None:
+                try:
+                    return fn(**params)
+                except TypeError as e:
+                    return _err(f"bad params for {action}: {e}")
+            return _err(f"oled has no method '{action}'")
+
         # Level 2: Motor
         if self._motors:
             lp = params.get("left_pin", 17)

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/core/tool_builder.py

@@ -1556,6 +1556,356 @@ class TFLiteTool:
             return _err(str(e))
 
 
+# ── OLEDTool ──────────────────────────────────────────────────────────
+
+_OLED_SIM_DIR = os.path.join("logs", "oled_sim")
+_OLED_W = 128
+_OLED_H = 64
+
+_FACE_DEFS = {
+    "neutral":  {"eyes": "open",    "mouth": "flat"},
+    "happy":    {"eyes": "open",    "mouth": "smile"},
+    "thinking": {"eyes": "squint",  "mouth": "flat"},
+    "alert":    {"eyes": "wide",    "mouth": "open"},
+    "sleeping": {"eyes": "closed",  "mouth": "flat"},
+    "speaking": {"eyes": "open",    "mouth": "open"},
+}
+
+
+class OLEDTool:
+    """Controls an SSD1306/SSD1309 128x64 SPI OLED display (with simulation fallback).
+
+    Modes:
+      - real: luma.oled SSD1306 driver on SPI (DC=GPIO25, RST=GPIO24, CE0)
+      - sim: renders frames to PNG files under logs/oled_sim/ for review
+    """
+
+    def __init__(self, spi_port: int = 0, spi_device: int = 0,
+                 gpio_dc: int = 25, gpio_rst: int = 24,
+                 width: int = _OLED_W, height: int = _OLED_H,
+                 force_sim: bool = False):
+        self._width = width
+        self._height = height
+        self._spi_port = spi_port
+        self._spi_device = spi_device
+        self._gpio_dc = gpio_dc
+        self._gpio_rst = gpio_rst
+        self._mode = "sim"
+        self._device = None
+        self._Image = None
+        self._ImageDraw = None
+        self._ImageFont = None
+        self._frame_counter = 0
+
+        # PIL is required for both real and sim modes
+        try:
+            from PIL import Image, ImageDraw, ImageFont
+            self._Image = Image
+            self._ImageDraw = ImageDraw
+            self._ImageFont = ImageFont
+        except ImportError:
+            self._Image = None
+
+        if not force_sim and _ON_PI and self._Image is not None:
+            try:
+                from luma.core.interface.serial import spi
+                from luma.oled.device import ssd1306
+                serial = spi(port=spi_port, device=spi_device,
+                             gpio_DC=gpio_dc, gpio_RST=gpio_rst)
+                self._device = ssd1306(serial, width=width, height=height)
+                self._mode = "real"
+            except Exception:
+                self._device = None
+                self._mode = "sim"
+
+        if self._mode == "sim":
+            try:
+                os.makedirs(_OLED_SIM_DIR, exist_ok=True)
+            except OSError:
+                pass
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+    # ── Internal rendering helpers ─────────────────────────────────
+
+    def _new_image(self):
+        return self._Image.new("1", (self._width, self._height), 0)
+
+    def _font(self, size: int = 12):
+        try:
+            return self._ImageFont.truetype(
+                "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", size)
+        except (OSError, IOError):
+            return self._ImageFont.load_default()
+
+    def _text_size(self, draw, text, font):
+        try:
+            l, t, r, b = draw.textbbox((0, 0), text, font=font)
+            return r - l, b - t
+        except AttributeError:
+            return draw.textsize(text, font=font)
+
+    def _wrap_text(self, draw, text, font, max_w):
+        words = text.split()
+        lines: list = []
+        current = ""
+        for w in words:
+            trial = (current + " " + w).strip()
+            tw, _ = self._text_size(draw, trial, font)
+            if tw <= max_w or not current:
+                current = trial
+            else:
+                lines.append(current)
+                current = w
+        if current:
+            lines.append(current)
+        return lines
+
+    def _push(self, img, tag: str = "frame"):
+        if self._mode == "real" and self._device is not None:
+            try:
+                self._device.display(img)
+                return _ok({"mode": "real", "tag": tag})
+            except Exception as e:
+                return _err(f"oled display failed: {e}")
+        # sim mode: save PNG (scaled 4x for visibility)
+        try:
+            self._frame_counter += 1
+            fname = f"{tag}_{self._frame_counter:04d}.png"
+            path = os.path.join(_OLED_SIM_DIR, fname)
+            big = img.resize((self._width * 4, self._height * 4),
+                             self._Image.NEAREST)
+            big.convert("L").save(path)
+            return _ok({"mode": "sim", "path": path, "tag": tag})
+        except Exception as e:
+            return _err(f"oled sim save failed: {e}")
+
+    # ── Public methods ─────────────────────────────────────────────
+
+    def clear(self) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        img = self._new_image()
+        return self._push(img, tag="clear")
+
+    def clear_oled(self) -> Dict:
+        return self.clear()
+
+    def display_text(self, text: str = "", font_size: int = 12,
+                     x: int = 0, y: int = 0, clear: bool = True) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        img = self._new_image() if clear else self._new_image()
+        draw = self._ImageDraw.Draw(img)
+        font = self._font(font_size)
+        max_w = self._width - x
+        lines = self._wrap_text(draw, str(text), font, max_w)
+        line_h = font_size + 2
+        cy = y
+        for line in lines:
+            if cy + line_h > self._height:
+                break
+            draw.text((x, cy), line, fill=1, font=font)
+            cy += line_h
+        return self._push(img, tag="text")
+
+    def display_image(self, image_path: str = "") -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        path = _extract_image_path(image_path)
+        if not path or not os.path.exists(path):
+            return _err(f"image not found: {path}")
+        try:
+            src = self._Image.open(path).convert("1")
+            src = src.resize((self._width, self._height))
+            return self._push(src, tag="image")
+        except Exception as e:
+            return _err(f"load image failed: {e}")
+
+    def show_animation(self, frames: list = None, fps: int = 10) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        frames = frames or []
+        if not frames:
+            return _err("no frames provided")
+        delay = 1.0 / max(fps, 1)
+        last = None
+        for f in frames:
+            if isinstance(f, str):
+                if not os.path.exists(f):
+                    continue
+                img = self._Image.open(f).convert("1").resize(
+                    (self._width, self._height))
+            else:
+                img = f.convert("1").resize((self._width, self._height))
+            last = self._push(img, tag="anim")
+            time.sleep(delay)
+        return last or _err("no playable frames")
+
+    # ── Face drawing ───────────────────────────────────────────────
+
+    def _draw_eye_pair(self, draw, state: str):
+        """Draw both eyes. Positions: left (35,25), right (93,25)."""
+        lx, rx, ey = 35, 93, 25
+        r = 10
+        pr = 4  # pupil radius
+
+        if state == "closed":
+            draw.line((lx - r, ey, lx + r, ey), fill=1, width=3)
+            draw.line((rx - r, ey, rx + r, ey), fill=1, width=3)
+        elif state == "squint":
+            # Smaller ovals
+            draw.ellipse((lx - r, ey - 5, lx + r, ey + 5), fill=1)
+            draw.ellipse((rx - r, ey - 5, rx + r, ey + 5), fill=1)
+            draw.ellipse((lx - pr, ey - 2, lx + pr, ey + 2), fill=0)
+            draw.ellipse((rx - pr, ey - 2, rx + pr, ey + 2), fill=0)
+        elif state == "wide":
+            wr = r + 3
+            draw.ellipse((lx - wr, ey - wr, lx + wr, ey + wr), fill=1)
+            draw.ellipse((rx - wr, ey - wr, rx + wr, ey + wr), fill=1)
+            draw.ellipse((lx - 5, ey - 5, lx + 5, ey + 5), fill=0)
+            draw.ellipse((rx - 5, ey - 5, rx + 5, ey + 5), fill=0)
+        elif state == "wink_left":
+            draw.line((lx - r, ey, lx + r, ey), fill=1, width=3)
+            draw.ellipse((rx - r, ey - r, rx + r, ey + r), fill=1)
+            draw.ellipse((rx - pr, ey - pr, rx + pr, ey + pr), fill=0)
+        elif state == "wink_right":
+            draw.ellipse((lx - r, ey - r, lx + r, ey + r), fill=1)
+            draw.ellipse((lx - pr, ey - pr, lx + pr, ey + pr), fill=0)
+            draw.line((rx - r, ey, rx + r, ey), fill=1, width=3)
+        else:  # open
+            draw.ellipse((lx - r, ey - r, lx + r, ey + r), fill=1)
+            draw.ellipse((rx - r, ey - r, rx + r, ey + r), fill=1)
+            draw.ellipse((lx - pr, ey - pr, lx + pr, ey + pr), fill=0)
+            draw.ellipse((rx - pr, ey - pr, rx + pr, ey + pr), fill=0)
+
+    def _draw_mouth(self, draw, kind: str):
+        my = 52
+        if kind == "smile":
+            draw.arc((44, my - 8, 84, my + 8), 0, 180, fill=1, width=2)
+        elif kind == "open":
+            draw.ellipse((54, my - 5, 74, my + 5), outline=1, width=2)
+        elif kind == "frown":
+            draw.arc((44, my - 8, 84, my + 8), 180, 0, fill=1, width=2)
+        else:  # flat
+            draw.line((44, my, 84, my), fill=1, width=2)
+
+    def draw_face(self, expression: str = "neutral") -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        spec = _FACE_DEFS.get(expression, _FACE_DEFS["neutral"])
+        img = self._new_image()
+        draw = self._ImageDraw.Draw(img)
+        self._draw_eye_pair(draw, spec["eyes"])
+        mouth = spec["mouth"]
+        # thinking gets a frown/arc-up mouth
+        if expression == "thinking":
+            mouth = "frown"
+        self._draw_mouth(draw, mouth)
+        return self._push(img, tag=f"face_{expression}")
+
+    def draw_eyes(self, state: str = "open", blink: bool = False) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        img = self._new_image()
+        draw = self._ImageDraw.Draw(img)
+        self._draw_eye_pair(draw, "closed" if blink else state)
+        return self._push(img, tag=f"eyes_{state}")
+
+    def animate_blink(self, times: int = 2) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        last = None
+        for _ in range(max(1, int(times))):
+            # Open eyes + smile mouth
+            img = self._new_image()
+            draw = self._ImageDraw.Draw(img)
+            self._draw_eye_pair(draw, "open")
+            self._draw_mouth(draw, "smile")
+            self._push(img, tag="blink_open")
+            time.sleep(0.4)
+            # Closed eyes + smile mouth
+            img = self._new_image()
+            draw = self._ImageDraw.Draw(img)
+            self._draw_eye_pair(draw, "closed")
+            self._draw_mouth(draw, "smile")
+            last = self._push(img, tag="blink_closed")
+            time.sleep(0.15)
+        # End with neutral face
+        last = self.draw_face("neutral")
+        return last or _ok({"mode": self._mode, "blinks": times})
+
+    def animate_speaking(self, duration: float = 2.0) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        end = time.time() + max(0.2, float(duration))
+        last = None
+        while time.time() < end:
+            last = self.draw_face("speaking")
+            time.sleep(0.15)
+            last = self.draw_face("neutral")
+            time.sleep(0.15)
+        return last or _ok({"mode": self._mode, "duration": duration})
+
+    def scroll_text(self, text: str = "", speed: int = 3) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        font = self._font(16)
+        tmp = self._new_image()
+        draw = self._ImageDraw.Draw(tmp)
+        tw, th = self._text_size(draw, str(text), font)
+        y = (self._height - th) // 2
+        step_px = max(1, int(speed))
+        last = None
+        for offset in range(self._width, -tw - 1, -step_px):
+            img = self._new_image()
+            d2 = self._ImageDraw.Draw(img)
+            d2.text((offset, y), str(text), fill=1, font=font)
+            last = self._push(img, tag="scroll")
+            time.sleep(0.03)
+        return last or _ok({"mode": self._mode})
+
+    def show_value(self, label: str = "", value: Any = "",
+                   unit: str = "") -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        img = self._new_image()
+        draw = self._ImageDraw.Draw(img)
+        label_font = self._font(12)
+        value_font = self._font(28)
+        lw, lh = self._text_size(draw, str(label), label_font)
+        draw.text(((self._width - lw) // 2, 2), str(label),
+                  fill=1, font=label_font)
+        display_val = f"{value}{unit}" if unit else str(value)
+        vw, vh = self._text_size(draw, display_val, value_font)
+        draw.text(((self._width - vw) // 2,
+                   (self._height - vh) // 2 + 6),
+                  display_val, fill=1, font=value_font)
+        return self._push(img, tag="value")
+
+    def show_startup(self) -> Dict:
+        if self._Image is None:
+            return _err("PIL not available")
+        lx, rx, ey = 35, 93, 25
+        # Eyes grow open animation
+        for size in (2, 5, 8, 10):
+            img = self._new_image()
+            draw = self._ImageDraw.Draw(img)
+            draw.ellipse((lx - size, ey - size, lx + size, ey + size), fill=1)
+            draw.ellipse((rx - size, ey - size, rx + size, ey + size), fill=1)
+            self._push(img, tag=f"startup_{size}")
+            time.sleep(0.1)
+        # Happy face
+        self.draw_face("happy")
+        time.sleep(0.5)
+        # AETHER v3 text
+        self.display_text("AETHER v3", clear=True)
+        time.sleep(1.0)
+        return self.draw_face("neutral")
+
+
 # ── ToolBuilder ───────────────────────────────────────────────────────
 
 class ToolBuilder:
@@ -1606,6 +1956,19 @@ class ToolBuilder:
             cam = tools.get("camera")
             tools["tflite"] = TFLiteTool(camera_tool=cam)
 
+        # OLEDTool — if OLED detected OR PIL installed (sim fallback)
+        oled_info = hw.get("oled", {})
+        oled_available = bool(oled_info.get("available", False))
+        if oled_available or sw.get("PIL", False):
+            pins = oled_info.get("pins", {})
+            tools["oled"] = OLEDTool(
+                spi_port=pins.get("port", 0),
+                spi_device=pins.get("device", 0),
+                gpio_dc=pins.get("DC", 25),
+                gpio_rst=pins.get("RST", 24),
+                force_sim=not oled_available,
+            )
+
         # MotorTool — always (falls back to simulation logging)
         motor_ctrls = self._manifest.get("motor_controllers", [])
         motor_config = {

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/core/tool_discovery.py

@@ -160,6 +160,43 @@ def _probe_imu_i2c_dev() -> Tuple[bool, Dict]:
     return False, {"detail": "/dev/i2c-1 not found"}
 
 
+def _probe_oled() -> Tuple[bool, Dict]:
+    """Detect SPI-based SSD1306/SSD1309 OLED on Raspberry Pi.
+
+    Checks /dev/spidev0.0 or /dev/spidev0.1 for SPI availability,
+    then verifies luma.oled can be imported.
+    Returns a three-state result:
+      - available=True: SPI device exists AND luma.oled importable
+      - spi_ready=True but available=False: SPI ok, library missing
+      - spi_ready=False: SPI interface not enabled
+    """
+    base_info = {
+        "interface": "spi",
+        "type": "SSD1306",
+        "resolution": "128x64",
+        "pins": {"DC": 25, "RST": 24, "port": 0, "device": 0},
+    }
+
+    # Check SPI device nodes
+    spi_ready = (os.path.exists("/dev/spidev0.0")
+                 or os.path.exists("/dev/spidev0.1"))
+
+    if not spi_ready:
+        return False, {**base_info, "spi_ready": False,
+                       "spi_not_enabled": True,
+                       "detail": "SPI not enabled"}
+
+    # SPI device exists — check if luma.oled is importable
+    try:
+        from luma.oled.device import ssd1306 as _  # noqa: F401
+        return True, {**base_info, "spi_ready": True,
+                      "spi_not_enabled": False}
+    except ImportError:
+        return False, {**base_info, "spi_ready": True,
+                       "spi_not_enabled": False,
+                       "detail": "luma.oled not installed"}
+
+
 # ── Motor Controller Detection ────────────────────────────────────────
 #
 # Priority order: MAVLink FC → PCA9685 I2C → GPIO direct → ROS → USB
@@ -609,6 +646,8 @@ _SOFTWARE_PACKAGES = [
     ("serial",     "pyserial",       3),
     ("tflite_runtime","TFLite Runtime", 5),
     ("ultralytics","Ultralytics",    5),
+    ("PIL",        "Pillow",         4),
+    ("luma.oled",  "luma.oled",      3),
 ]
 
 
@@ -747,6 +786,10 @@ _CAPABILITY_ACTION_MAP: Dict[str, List[str]] = {
     "microphone":       ["audio_capture"],
     "speaker":          ["audio_playback"],
     "display":          ["display_render"],
+    "oled_ssd1306":     ["display_text", "draw_face", "animate_blink",
+                         "animate_speaking", "draw_eyes", "show_value",
+                         "scroll_text", "clear_oled", "display_image",
+                         "show_animation", "show_startup"],
     "gpu":              ["drl_inference", "gpu_compute"],
     "storage":          ["file_ops"],
     # Software → actions
@@ -779,7 +822,7 @@ _PROBE_WEIGHTS: Dict[str, int] = {
     "gpio": 8, "gpiozero": 5, "i2c": 5,
     "mavlink": 8, "dronekit": 5,
     "imu_mpu6050": 6, "i2c_imu": 3,
-    "microphone": 4, "speaker": 3, "display": 3,
+    "microphone": 4, "speaker": 3, "display": 3, "oled_ssd1306": 5,
     "storage": 5, "gpu": 8,
     "internet": 10, "local_network": 3,
     "numpy": 12, "anthropic": 12, "psutil": 8, "torch": 8,
@@ -902,6 +945,11 @@ class ToolDiscovery:
                 hw["imu"] = {"available": False}
                 self._record("imu_mpu6050", False, imu_info, CAT_HARDWARE)
 
+        # OLED display (SPI SSD1306/SSD1309)
+        oled_ok, oled_info = _probe_oled()
+        hw["oled"] = {"available": oled_ok, **oled_info}
+        self._record("oled_ssd1306", oled_ok, oled_info, CAT_HARDWARE)
+
         # Motor controller auto-detection (replaces simple mavlink probe)
         motor_controllers = _detect_motor_controllers(self._serial_ports)
         self._motor_controllers = motor_controllers
@@ -1132,7 +1180,7 @@ class ToolDiscovery:
         # Hardware
         print(f"\n  Hardware:")
         hw_order = ["camera", "gpio", "i2c", "imu", "mavlink",
-                    "audio", "display", "storage", "gpu"]
+                    "audio", "display", "oled", "storage", "gpu"]
         for key in hw_order:
             info = self._hardware.get(key, {})
             avail = info.get("available", False)
@@ -1150,8 +1198,19 @@ class ToolDiscovery:
                     detail = f"{info.get('free_gb', '?')}GB free / {info.get('total_gb', '?')}GB"
                 if key == "gpu":
                     detail = info.get("device", info.get("type", ""))
+                if key == "oled":
+                    iface = info.get("interface", "spi").upper()
+                    detail = f"{hw_type} {resolution} {iface}"
             else:
-                detail = info.get("detail", "not detected")
+                if key == "oled":
+                    if info.get("spi_not_enabled"):
+                        detail = "SPI not enabled"
+                    elif info.get("spi_ready"):
+                        detail = "library not installed"
+                    else:
+                        detail = info.get("detail", "not detected")
+                else:
+                    detail = info.get("detail", "not detected")
             print(f"    [{icon}] {key:<14} {status:<6} {detail}")
 
         # Software
@@ -1207,6 +1266,14 @@ class ToolDiscovery:
             print(f"    Unavailable: {', '.join(unavail[:10])}"
                   + ("..." if len(unavail) > 10 else ""))
 
+        # OLED SPI warning if on Pi with SPI disabled
+        oled_hw = self._hardware.get("oled", {})
+        if oled_hw.get("spi_not_enabled"):
+            print(f"\n  [OLED] SPI interface not enabled.")
+            print(f"  [OLED] To enable: sudo raspi-config → "
+                  f"Interface Options → SPI → Enable → Reboot")
+            print(f"  [OLED] Then reconnect and OLED will auto-configure.")
+
         # Score bar
         score = self._score
         bar_len = 25

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/aether/core/tool_registry.py

@@ -846,6 +846,19 @@ def register_built_tools(registry: "ToolRegistry",
             ("count_objects", "Count objects of a given class via YOLO detection"),
             ("describe_scene", "Describe everything visible (YOLO or Anthropic vision API)"),
         ],
+        "oled": [
+            ("display_text", "Display text on OLED (auto-wraps long text)"),
+            ("display_image", "Display an image file on OLED (auto-resized to 128x64)"),
+            ("clear_oled", "Clear the OLED screen"),
+            ("show_animation", "Play a list of image frames on OLED at given fps"),
+            ("draw_face", "Draw a robot face expression on OLED (neutral, happy, thinking, alert, sleeping, speaking)"),
+            ("draw_eyes", "Draw animated eyes on OLED (open, closed, squint, wide, wink_left, wink_right)"),
+            ("animate_blink", "Blink eyes N times on OLED"),
+            ("animate_speaking", "Animate mouth opening/closing for N seconds"),
+            ("scroll_text", "Scroll text across the OLED from right to left"),
+            ("show_value", "Display a large centered value with label and unit"),
+            ("show_startup", "Play OLED startup animation with AETHER logo"),
+        ],
         # storage methods overlap with existing ReadFileTool/WriteFileTool,
         # so we skip them to avoid name collisions
     }
@@ -880,6 +893,7 @@ def register_built_tools(registry: "ToolRegistry",
                     "i2c": hw.get("i2c", {}),
                     "imu": hw.get("imu", {}),
                     "mavlink": hw.get("mavlink", {}),
+                    "oled": hw.get("oled", {}),
                     "serial_ports": hw.get("serial_ports", []),
                 },
                 "software": {k: v for k, v in sw.items()},
@@ -899,6 +913,8 @@ def register_built_tools(registry: "ToolRegistry",
                 missing.append("IMU sensor (would enable: accelerometer, gyroscope, orientation)")
             if not hw.get("i2c", {}).get("available"):
                 missing.append("I2C bus (would enable: external sensors, OLED displays)")
+            if not hw.get("oled", {}).get("available"):
+                missing.append("OLED display at I2C 0x3C/0x3D (would enable: on-device text, robot face, status readouts)")
             if not hw.get("gpu", {}).get("available"):
                 missing.append("CUDA/MPS GPU (would enable: fast inference, ML training)")
             if not net.get("internet"):

{aether_robotics-3.2.0 → aether_robotics-3.2.3/aether_robotics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 3.2.0
+Version: 3.2.3
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT

{aether_robotics-3.2.0 → aether_robotics-3.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aether-robotics"
-version = "3.2.0"
+version = "3.2.3"
 description = "Autonomous multi-agent robotics system with DRL-First Hybrid FDIR"
 readme = "README.md"
 license = {text = "MIT"}

aether_robotics-3.2.0/VERSION

@@ -1 +0,0 @@
-3.2.0