urkit 0.1.0__tar.gz → 0.1.1__tar.gz

{urkit-0.1.0 → urkit-0.1.1}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: urkit
-Version: 0.1.0
+Version: 0.1.1
 Summary: Universal Robots e-Series control toolkit built on ur_rtde
 Author: URKit Contributors
 License: MIT
+Project-URL: Repository, https://github.com/rodolfo-verde/urkit
 Keywords: universal-robots,ur3e,ur5e,ur7e,ur10e,ur12e,ur16e,ur8,ur15,ur18,ur20,ur30,rtde,robotics,industrial-robot
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -25,6 +26,8 @@ Requires-Dist: rich>=13.0.0
 
 # URKit
 
+[![PyPI](https://img.shields.io/pypi/v/urkit.svg)](https://pypi.org/project/urkit/)
+
 **URKit** is a Python toolkit for [Universal Robots](https://www.universal-robots.com/) e-Series robots that makes the common stuff simple and gets out of the way for everything else.
 
 Built on [`ur_rtde`](https://sdurobotics.gitlab.io/ur_rtde/), it packages the operations you reach for most: connecting, moving to named points, gripper control, telemetry, and I/O, while exposing the raw RTDE interfaces for anything deeper. It doesn't try to replace `ur_rtde`; it sits on top of it so you can use both in tandem.
@@ -103,17 +106,20 @@ urkit teach                           # reads IP from config.yaml
 | Flag | Description |
 |------|-------------|
 | `ip` | Robot IP address (positional, overrides config) |
-| `--gripper` | Gripper preset: `2f-85`, `2f-140`, `hand-e`, `digital` |
+| `--gripper` | Gripper preset: `2f-85`, `2f-140`, `hand-e`, `digital`, `none` |
 | `--gripper-pin` | Digital gripper output pin (default: 0) |
 | `--gripper-force` | Robotiq force 0-100 |
 | `--gripper-speed` | Robotiq speed 0-100 |
 | `--gripper-close-on-high` | Digital polarity: `true` or `false` |
 | `--points` | Path to `points.db` file (overrides config) |
+| `--config` | Path to config file (default: `config.yaml` in project root or CWD) |
 | `-v`, `--verbose` | Show verbose output (debug connection issues) |
 
 ```bash
 urkit teach 172.31.1.200 --gripper hand-e --points /path/to/points.db
 urkit teach --gripper digital --gripper-pin 3
+urkit teach --gripper none            # no gripper (overrides config)
+urkit teach --config /path/to/my.yaml # load custom config
 urkit teach -v                        # verbose mode
 ```
 
@@ -210,10 +216,11 @@ All movement and orientation keys support **hold-to-repeat** — hold a key down
     <td align="center" style="width:50%">
       <table>
         <tr><th>Key</th><th>Action</th></tr>
-        <tr><td><code>F</code></td><td>Freedrive (OFF → ALL → XYZ)</td></tr>
+        <tr><td><code>F</code></td><td>Freedrive (OFF → ALL → XYZ+Rz)</td></tr>
         <tr><td><code>M</code></td><td>Toggle frame (BASE / TOOL)</td></tr>
         <tr><td><code>N</code></td><td>Go To mode (Cartesian / Joint)</td></tr>
         <tr><td><code>T</code></td><td>Orient TCP down (180°)</td></tr>
+        <tr><td><code>Y</code></td><td>Save config to file</td></tr>
         <tr><td><code>ESC</code></td><td>Exit</td></tr>
       </table>
     </td>
@@ -249,22 +256,110 @@ robot = URRobot(
 
 ### From Config
 
-Store your config in a `config.yaml`:
+```python
+robot = URRobot.from_config("config.yaml")
+robot = URRobot.from_config("config.yaml", ip="10.0.0.50")  # override IP
+```
+
+See the [Configuration](#configuration) section for full details on config location, keys, and saving.
+
+---
+
+## Configuration
+
+URKit uses a YAML config file (`config.yaml`) to persist settings between sessions. The CLI reads it automatically, and `URRobot.from_config()` loads it programmatically.
+
+### Config File Location
+
+URKit searches for `config.yaml` in this order:
+1. Explicit path via `--config` flag or `load_config("path")`
+2. Project root (where `src/urkit` lives)
+3. Current working directory
+
+If no config file exists, URKit uses built-in defaults and operates fine — the config is optional.
+
+### Config Keys
+
+| Key | Description | Example |
+|-----|-------------|---------|
+| `robot_ip` | Robot IP address | `192.168.1.100` |
+| `points_path` | Path to SQLite points database | `points.db` |
+| `gripper` | Gripper preset name | `hand-e`, `2f-85`, `2f-140`, `digital` |
+| `default_vel` | Default linear velocity (m/s) | `0.5` |
+| `default_acc` | Default linear acceleration (m/s²) | `0.3` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+
+### Gripper Config Section
+
+For digital grippers, specify pin and polarity:
+
+```yaml
+gripper: digital
+gripper_config:
+  pin: 3
+  close_on_high: true
+```
+
+For Robotiq grippers, override preset values:
 
 ```yaml
-robot_ip: 172.31.1.200
-points_path: points.db
 gripper: hand-e
-default_vel: 0.5
-default_acc: 0.3
-rtde_frequency: 125
+gripper_config:
+  force: 50
+  speed: 80
 ```
 
-Then load it:
+### CLI Override Precedence
+
+Settings are resolved in this order (highest priority first):
+
+1. **CLI flags** — `urkit teach 172.31.1.200 --gripper none`
+2. **Config file** — values from `config.yaml`
+3. **Built-in defaults** — `points.db` for points, no gripper, `0.5` m/s velocity
+
+Use `--gripper none` to explicitly disable a gripper that's set in your config file.
+
+### Saving Config
+
+The CLI **never** modifies your config file automatically. Inside the teach pendant, press **Y** to save your current session's settings (IP, gripper, points path) to the config file. This way you only save settings you've actually tested and verified work.
+
+```bash
+# First connection — test everything, then press Y inside the pendant
+urkit teach 172.31.1.200 --gripper hand-e
+
+# After pressing Y, config.yaml is saved. Next time:
+urkit teach                          # reads IP + gripper from config
+
+# Custom config file
+urkit teach --config station_a.yaml  # load from custom path
+# press Y inside → saves back to station_a.yaml
+```
+
+This lets you maintain separate configs per workcell:
+
+```bash
+urkit teach --config station_a.yaml  # press Y to save
+urkit teach --config station_b.yaml  # press Y to save
+```
+
+### Programmatic Config
 
 ```python
-robot = URRobot.from_config("config.yaml")
-robot = URRobot.from_config("config.yaml", ip="10.0.0.50")  # override IP
+from urkit import load_config, resolve_config
+
+# Load with auto-resolution
+config = load_config()  # searches for config.yaml
+config = load_config("/path/to/my.yaml")  # explicit path
+
+# Check if config exists
+path = resolve_config()  # returns Path or None
+
+# Create robot from config dict
+robot = URRobot.from_config({"robot_ip": "172.31.1.200", "gripper": "2f-85"})
 ```
 
 ---
@@ -478,7 +573,7 @@ from urkit import FreedriveMode
 
 # Freedrive lets you manually push the robot: motion commands won't work while active
 robot.enable_freedrive()              # all 6 axes free
-robot.enable_freedrive(FreedriveMode.XYZ)      # linear axes only
+robot.enable_freedrive(FreedriveMode.XYZ)      # linear axes + Rz rotation
 robot.enable_freedrive(FreedriveMode.ROTATION) # rotation only
 robot.disable_freedrive()             # always disable before sending motion commands
 

{urkit-0.1.0 → urkit-0.1.1}/README.md

@@ -1,5 +1,7 @@
 # URKit
 
+[![PyPI](https://img.shields.io/pypi/v/urkit.svg)](https://pypi.org/project/urkit/)
+
 **URKit** is a Python toolkit for [Universal Robots](https://www.universal-robots.com/) e-Series robots that makes the common stuff simple and gets out of the way for everything else.
 
 Built on [`ur_rtde`](https://sdurobotics.gitlab.io/ur_rtde/), it packages the operations you reach for most: connecting, moving to named points, gripper control, telemetry, and I/O, while exposing the raw RTDE interfaces for anything deeper. It doesn't try to replace `ur_rtde`; it sits on top of it so you can use both in tandem.
@@ -78,17 +80,20 @@ urkit teach                           # reads IP from config.yaml
 | Flag | Description |
 |------|-------------|
 | `ip` | Robot IP address (positional, overrides config) |
-| `--gripper` | Gripper preset: `2f-85`, `2f-140`, `hand-e`, `digital` |
+| `--gripper` | Gripper preset: `2f-85`, `2f-140`, `hand-e`, `digital`, `none` |
 | `--gripper-pin` | Digital gripper output pin (default: 0) |
 | `--gripper-force` | Robotiq force 0-100 |
 | `--gripper-speed` | Robotiq speed 0-100 |
 | `--gripper-close-on-high` | Digital polarity: `true` or `false` |
 | `--points` | Path to `points.db` file (overrides config) |
+| `--config` | Path to config file (default: `config.yaml` in project root or CWD) |
 | `-v`, `--verbose` | Show verbose output (debug connection issues) |
 
 ```bash
 urkit teach 172.31.1.200 --gripper hand-e --points /path/to/points.db
 urkit teach --gripper digital --gripper-pin 3
+urkit teach --gripper none            # no gripper (overrides config)
+urkit teach --config /path/to/my.yaml # load custom config
 urkit teach -v                        # verbose mode
 ```
 
@@ -185,10 +190,11 @@ All movement and orientation keys support **hold-to-repeat** — hold a key down
     <td align="center" style="width:50%">
       <table>
         <tr><th>Key</th><th>Action</th></tr>
-        <tr><td><code>F</code></td><td>Freedrive (OFF → ALL → XYZ)</td></tr>
+        <tr><td><code>F</code></td><td>Freedrive (OFF → ALL → XYZ+Rz)</td></tr>
         <tr><td><code>M</code></td><td>Toggle frame (BASE / TOOL)</td></tr>
         <tr><td><code>N</code></td><td>Go To mode (Cartesian / Joint)</td></tr>
         <tr><td><code>T</code></td><td>Orient TCP down (180°)</td></tr>
+        <tr><td><code>Y</code></td><td>Save config to file</td></tr>
         <tr><td><code>ESC</code></td><td>Exit</td></tr>
       </table>
     </td>
@@ -224,22 +230,110 @@ robot = URRobot(
 
 ### From Config
 
-Store your config in a `config.yaml`:
+```python
+robot = URRobot.from_config("config.yaml")
+robot = URRobot.from_config("config.yaml", ip="10.0.0.50")  # override IP
+```
+
+See the [Configuration](#configuration) section for full details on config location, keys, and saving.
+
+---
+
+## Configuration
+
+URKit uses a YAML config file (`config.yaml`) to persist settings between sessions. The CLI reads it automatically, and `URRobot.from_config()` loads it programmatically.
+
+### Config File Location
+
+URKit searches for `config.yaml` in this order:
+1. Explicit path via `--config` flag or `load_config("path")`
+2. Project root (where `src/urkit` lives)
+3. Current working directory
+
+If no config file exists, URKit uses built-in defaults and operates fine — the config is optional.
+
+### Config Keys
+
+| Key | Description | Example |
+|-----|-------------|---------|
+| `robot_ip` | Robot IP address | `192.168.1.100` |
+| `points_path` | Path to SQLite points database | `points.db` |
+| `gripper` | Gripper preset name | `hand-e`, `2f-85`, `2f-140`, `digital` |
+| `default_vel` | Default linear velocity (m/s) | `0.5` |
+| `default_acc` | Default linear acceleration (m/s²) | `0.3` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+
+### Gripper Config Section
+
+For digital grippers, specify pin and polarity:
+
+```yaml
+gripper: digital
+gripper_config:
+  pin: 3
+  close_on_high: true
+```
+
+For Robotiq grippers, override preset values:
 
 ```yaml
-robot_ip: 172.31.1.200
-points_path: points.db
 gripper: hand-e
-default_vel: 0.5
-default_acc: 0.3
-rtde_frequency: 125
+gripper_config:
+  force: 50
+  speed: 80
 ```
 
-Then load it:
+### CLI Override Precedence
+
+Settings are resolved in this order (highest priority first):
+
+1. **CLI flags** — `urkit teach 172.31.1.200 --gripper none`
+2. **Config file** — values from `config.yaml`
+3. **Built-in defaults** — `points.db` for points, no gripper, `0.5` m/s velocity
+
+Use `--gripper none` to explicitly disable a gripper that's set in your config file.
+
+### Saving Config
+
+The CLI **never** modifies your config file automatically. Inside the teach pendant, press **Y** to save your current session's settings (IP, gripper, points path) to the config file. This way you only save settings you've actually tested and verified work.
+
+```bash
+# First connection — test everything, then press Y inside the pendant
+urkit teach 172.31.1.200 --gripper hand-e
+
+# After pressing Y, config.yaml is saved. Next time:
+urkit teach                          # reads IP + gripper from config
+
+# Custom config file
+urkit teach --config station_a.yaml  # load from custom path
+# press Y inside → saves back to station_a.yaml
+```
+
+This lets you maintain separate configs per workcell:
+
+```bash
+urkit teach --config station_a.yaml  # press Y to save
+urkit teach --config station_b.yaml  # press Y to save
+```
+
+### Programmatic Config
 
 ```python
-robot = URRobot.from_config("config.yaml")
-robot = URRobot.from_config("config.yaml", ip="10.0.0.50")  # override IP
+from urkit import load_config, resolve_config
+
+# Load with auto-resolution
+config = load_config()  # searches for config.yaml
+config = load_config("/path/to/my.yaml")  # explicit path
+
+# Check if config exists
+path = resolve_config()  # returns Path or None
+
+# Create robot from config dict
+robot = URRobot.from_config({"robot_ip": "172.31.1.200", "gripper": "2f-85"})
 ```
 
 ---
@@ -453,7 +547,7 @@ from urkit import FreedriveMode
 
 # Freedrive lets you manually push the robot: motion commands won't work while active
 robot.enable_freedrive()              # all 6 axes free
-robot.enable_freedrive(FreedriveMode.XYZ)      # linear axes only
+robot.enable_freedrive(FreedriveMode.XYZ)      # linear axes + Rz rotation
 robot.enable_freedrive(FreedriveMode.ROTATION) # rotation only
 robot.disable_freedrive()             # always disable before sending motion commands
 

{urkit-0.1.0 → urkit-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "urkit"
-version = "0.1.0"
+version = "0.1.1"
 description = "Universal Robots e-Series control toolkit built on ur_rtde"
 readme = "README.md"
 license = {text = "MIT"}
@@ -12,6 +12,7 @@ requires-python = ">=3.8"
 authors = [
     {name = "URKit Contributors"},
 ]
+
 keywords = [
     "universal-robots",
     "ur3e",
@@ -49,6 +50,9 @@ dependencies = [
     "rich>=13.0.0",
 ]
 
+[project.urls]
+Repository = "https://github.com/rodolfo-verde/urkit"
+
 [project.scripts]
 urkit = "urkit.__main__:main_entry"
 

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/__init__.py

@@ -24,6 +24,8 @@ Quick start::
 
 from __future__ import annotations
 
+from importlib.metadata import version as _metadata_version
+
 from urkit.config import load_config, resolve_config
 from urkit.exceptions import (
     URKitError,
@@ -57,7 +59,7 @@ from urkit.gripper.presets import (
 from urkit.motion import FreedriveMode
 from urkit.robot import URRobot
 
-__version__ = "0.0.1"
+__version__ = _metadata_version("urkit")
 
 __all__ = [
     # Version

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/__main__.py

@@ -41,8 +41,8 @@ def main() -> None:
         "--gripper",
         type=str,
         default=None,
-        choices=["2f-85", "2f-140", "hand-e", "digital"],
-        help="Gripper preset (overrides config file)",
+        choices=["2f-85", "2f-140", "hand-e", "digital", "none"],
+        help="Gripper preset (overrides config file). Use 'none' to disable gripper",
     )
     teach_parser.add_argument(
         "--gripper-pin",
@@ -75,6 +75,12 @@ def main() -> None:
         default=None,
         help="Path to points.db file (overrides config file)",
     )
+    teach_parser.add_argument(
+        "--config",
+        type=str,
+        default=None,
+        help="Path to config file (default: config.yaml in project root or CWD)",
+    )
     teach_parser.add_argument(
         "-v", "--verbose",
         action="store_true",

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/cli/teach.py

@@ -101,10 +101,15 @@ def _compute_vel_acc(
         acc = min(vel * 3.0, _MAX_ACC)
     return vel, acc
 
-def _save_config(config: dict) -> None:
-    """Write configuration to <script_dir>/config.yaml."""
+def _save_config(config: dict, path: str | Path | None = None) -> None:
+    """Write configuration to config.yaml.
+
+    Args:
+        config: Configuration dict to save.
+        path: Explicit path. Falls back to resolved default config path.
+    """
     try:
-        config_path = _resolve_default_config_path()
+        config_path = Path(path) if path is not None else _resolve_default_config_path()
         config_path.parent.mkdir(parents=True, exist_ok=True)
         with open(config_path, "w") as f:
             yaml.dump(config, f, default_flow_style=False)
@@ -186,13 +191,14 @@ def _draw_screen(
         tcp_force = [0, 0, 0, 0, 0, 0]
 
     gripper_state = "None"
-    if robot.gripper and not state.get("freedrive"):
-        try:
-            gripper_state = "Connected" if robot.gripper.is_connected() else "Disconnected"
-        except Exception:
-            gripper_state = "?"
-    elif robot.gripper and state.get("freedrive"):
-        gripper_state = dim("(freedrive active)")
+    if robot.gripper:
+        pos_mm = robot.gripper.get_position_mm()
+        max_mm = robot.gripper.max_travel_mm()
+        if pos_mm is not None and max_mm is not None and max_mm > 0:
+            pct = int((max_mm - pos_mm) / max_mm * 100)
+            gripper_state = f"{green('Connected')} {pos_mm:.1f}mm ({pct}%)"
+        else:
+            gripper_state = green("Connected")
 
     lines: list[str] = []
 
@@ -212,9 +218,12 @@ def _draw_screen(
     lines.append(f" {blue('Go To:'.ljust(lw))} {green(goto_label)} {dim('[N: toggle Cartesian/Joint]')}")
     lines.append(f" {blue('Gripper:'.ljust(lw))} {gripper_state}")
     if state["freedrive"]:
-        lines.append(f" {blue('Freedrive:'.ljust(lw))} {green('ON')} ({state['freedrive_mode'].name})")
+        mode_label = state["freedrive_mode"].name
+        if mode_label == "XYZ":
+            mode_label = "XYZ+Rz"
+        lines.append(f" {blue('Freedrive:'.ljust(lw))} {green('ON')} ({mode_label})")
     else:
-        lines.append(f" {blue('Freedrive:'.ljust(lw))} {red('OFF')} {dim('[F: cycle ALL/XYZ]')}")
+        lines.append(f" {blue('Freedrive:'.ljust(lw))} {red('OFF')} {dim('[F: cycle ALL/XYZ+Rz]')}")
     slider_pct = int(state["speed_slider"] * 100)
     slider_color = green if state["speed_slider"] >= 0.5 else yellow if state["speed_slider"] >= 0.2 else red
     lines.append(f" {blue('Speed:'.ljust(lw))} {slider_color(f'{slider_pct}%')} {dim('[0: set]')}")
@@ -245,16 +254,18 @@ def _draw_screen(
     # Control reference
     lines.append(f"  {yellow('MOVE:')}    {yellow('W/S')}: ±X  {yellow('A/D')}: ±Y  {yellow('Q/E')}: ±Z")
     lines.append(f"  {yellow('ORIENT:')}  {yellow('U/O')}: ±Roll  {yellow('I/K')}: ±Pitch  {yellow('J/L')}: ±Yaw")
-    lines.append(f"  {yellow('STEP:')}    {yellow('1')}: Set Linear (mm)  {yellow('2')}: Set Angular (°)  {yellow('.')}: Reset")
-    lines.append(f"  {yellow('GRIPPER:')} {yellow('X')}: Open  {yellow('C')}: Close  {yellow('V')}: Set Position")
-    lines.append(f"  {yellow('POINTS:')}  {yellow('B')}: Save  {yellow('G')}: Go To  {yellow('H')}: Delete  {yellow('R')}: Rename")
-    lines.append(f"  {yellow('OTHER:')}   {yellow('F')}: Freedrive  {yellow('M')}: Frame  {yellow('N')}: Go To Mode  {yellow('T')}: TCP Down  {yellow('0')}: Speed")
-    lines.append(f"  {yellow('ESC')}:     Exit")
+    lines.append(f"  {yellow('STEP:')}    {yellow('1')}: Linear (mm)  {yellow('2')}: Angular (°)  {yellow('.')}: Reset")
+    lines.append(f"  {yellow('GRIPPER:')} {yellow('X')}: Open  {yellow('C')}: Close  {yellow('V')}: Position")
+    lines.append(f"  {yellow('POINTS:')}  {yellow('B')}: Save  {yellow('G')}: Go To  {yellow('H')}: Delete  {yellow('R')}: Rename  {yellow('P')}: Explorer")
+    lines.append(f"  {yellow('OTHER:')}   {yellow('F')}: Freedrive  {yellow('M')}: Frame  {yellow('N')}: GoTo Mode  {yellow('T')}: TCP Down")
+    lines.append(f"  {yellow('      ')}   {yellow('0')}: Speed  {yellow('Y')}: Save Config")
+    lines.append(f"  {yellow('EXIT:')}    {yellow('ESC')}")
     lines.append(dim("=" * width))
 
     # Clear and redraw
-    print("\033[2J\033[1;1H", end="")
-    print("\n".join(lines))
+    sys.stdout.write("\033[2J\033[1;1H")
+    sys.stdout.write("\n".join(lines) + "\n")
+    sys.stdout.flush()
 
 
 def _draw_help() -> None:
@@ -288,14 +299,16 @@ def _draw_help() -> None:
     lines.append("    G      → Go to saved point (ask cartesian/joint)")
     lines.append("    H      → Delete saved point")
     lines.append("    R      → Rename saved point")
+    lines.append("    P      → Open points explorer")
     lines.append("")
     lines.append("  OTHER:")
-    lines.append("    F      → Cycle freedrive: OFF → ALL → XYZ → OFF")
+    lines.append("    F      → Cycle freedrive: OFF → ALL → XYZ+Rz → OFF")
     lines.append("    M      → Toggle move frame: BASE / TOOL")
     lines.append("    T      → Orient TCP downward (roll=180°)")
     lines.append("    0      → Set speed slider (0-100%)")
+    lines.append("    Y      → Save config (IP, gripper, points path)")
     lines.append("")
-    lines.append("  ESC    → Exit")
+    lines.append("  Exit   → ESC")
     lines.append("=" * width)
     print("\n".join(lines))
 
@@ -710,6 +723,10 @@ class _ScreenLogHandler(logging.Handler):
 
 def _teach_pendant(
     robot: URRobot,
+    *,
+    config_path: str | Path | None = None,
+    current_gripper_name: str | None = None,
+    current_points_path: str | None = None,
 ) -> None:
     """Run the interactive teach pendant loop.
 
@@ -880,17 +897,10 @@ def _teach_pendant(
                 # --- Freedrive ---
                 elif key == "f":
                     if not state["freedrive"]:
-                        mode = state.get("_last_freedrive_mode", FreedriveMode.ALL)
-                        if mode == FreedriveMode.ALL:
-                            mode = FreedriveMode.XYZ
-                        else:
-                            mode = FreedriveMode.ALL
                         try:
-                            robot.enable_freedrive(mode)
+                            robot.enable_freedrive(FreedriveMode.ALL)
                             state["freedrive"] = True
-                            state["freedrive_mode"] = mode
-                            state["_last_freedrive_mode"] = mode
-                            messages.append(f"Freedrive {mode.name}")
+                            state["freedrive_mode"] = FreedriveMode.ALL
                         except MotionError as e:
                             messages.append(f"Freedrive error: {e}")
                     else:
@@ -899,15 +909,12 @@ def _teach_pendant(
                                 robot.disable_freedrive()
                                 robot.enable_freedrive(FreedriveMode.XYZ)
                                 state["freedrive_mode"] = FreedriveMode.XYZ
-                                state["_last_freedrive_mode"] = FreedriveMode.XYZ
-                                messages.append("Freedrive XYZ")
                             except MotionError as e:
                                 messages.append(f"Freedrive error: {e}")
                         else:
                             try:
                                 robot.disable_freedrive()
                                 state["freedrive"] = False
-                                messages.append("Freedrive OFF")
                             except MotionError as e:
                                 messages.append(f"Freedrive error: {e}")
                     command_handled = True
@@ -1016,6 +1023,19 @@ def _teach_pendant(
                         messages.append(f"Error: {e}")
                     command_handled = True
 
+                # --- Save config ---
+                elif key == "y":
+                    save_cfg: dict = {}
+                    save_cfg["robot_ip"] = robot.ip
+                    if current_gripper_name:
+                        save_cfg["gripper"] = current_gripper_name
+                    if current_points_path:
+                        save_cfg["points_path"] = current_points_path
+                    _save_config(save_cfg, config_path)
+                    target = Path(config_path) if config_path else _resolve_default_config_path()
+                    messages.append(f"Config saved to {target}")
+                    command_handled = True
+
                 # --- Redraw after movement or command ---
                 if moved or command_handled:
                     _draw_screen(robot, state, messages)
@@ -1058,12 +1078,15 @@ def teach_command(args) -> None:
     else:
         logging.basicConfig(level=logging.WARNING)
 
-    # Load config (last-used defaults)
-    config = load_config()
+    # Load config
+    config = load_config(args.config)
 
     # Resolve effective values: CLI arg > config > None
     ip = args.ip or config.get("robot_ip")
     gripper_name = args.gripper or config.get("gripper")
+    # "none" is an explicit CLI override — don't fall through to config
+    if gripper_name and gripper_name.lower() == "none":
+        gripper_name = None
     points_path = args.points or config.get("points_path") or "points.db"
 
     # Resolve gripper constructor params from config.yaml gripper_config section
@@ -1149,18 +1172,13 @@ def teach_command(args) -> None:
             )
         sys.exit(1)
 
-    # Auto-save last-used params to config
-    print(f"  Saving config...", flush=True)
-    save_cfg = dict(config)
-    save_cfg["robot_ip"] = ip
-    if gripper_name:
-        save_cfg["gripper"] = gripper_name
-    save_cfg["points_path"] = points_path
-    _save_config(save_cfg)
-    print(f"  Config saved.", flush=True)
-
     try:
-        _teach_pendant(robot)
+        _teach_pendant(
+            robot,
+            config_path=args.config,
+            current_gripper_name=gripper_name,
+            current_points_path=points_path,
+        )
     except KeyboardInterrupt:
         pass
     finally:

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/connection.py

@@ -170,7 +170,7 @@ def _validate_connection(ip: str, timeout: float = 5.0) -> dict[str, object]:
 def _connect_rtde(
     ip: str,
     *,
-    frequency: float = 125.0,
+    frequency: float = 500.0,
     max_wait: float = 30.0,
 ) -> Tuple[
     "RTDEControlInterface",
@@ -193,7 +193,7 @@ def _connect_rtde(
 
     Args:
         ip: Robot IP address.
-        frequency: RTDE communication frequency (default 125 Hz).
+        frequency: RTDE communication frequency (default 500 Hz).
         max_wait: Maximum time (seconds) to spend retrying the RTDE
             connection (default 30s).
 
@@ -296,7 +296,14 @@ def _connect_rtde(
                     f"EtherNet/IP, PROFINET, and MODBUS. Save and restart."
                 ) from e
 
-            # Retryable RuntimeError (e.g., "Failed to start control script")
+            if "start control script" in err_msg.lower():
+                raise ConnectionError(
+                    f"Failed to start the RTDE control script on the robot at {ip}. "
+                    f"This usually means a program is already occupying the secondary interface. "
+                    f"Stop any running program on the robot and try again."
+                ) from e
+
+            # Retryable RuntimeError (e.g., transient connection issues)
             remaining = max_wait - (time.time() - start)
             if remaining <= 0:
                 raise ConnectionError(

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/gripper/base.py

@@ -13,11 +13,10 @@ from abc import ABC, abstractmethod
 class Gripper(ABC):
     """Abstract base class for gripper backends.
 
-    Subclasses must implement ``open()``, ``close()``, ``set_position()``,
-    and ``is_connected()``. The ``activate()`` method is a no-op by
-    default and should be overridden by backends that require explicit
-    activation (e.g., Robotiq). The factory method ``Gripper.create()``
-    returns the appropriate backend.
+    Subclasses must implement ``open()``, ``close()``, and ``set_position()``.
+    The ``activate()`` method is a no-op by default and should be overridden
+    by backends that require explicit activation (e.g., Robotiq). The factory
+    method ``Gripper.create()`` returns the appropriate backend.
     """
 
     @abstractmethod
@@ -71,13 +70,24 @@ class Gripper(ABC):
         to re-enable the gripper.
         """
 
-    @abstractmethod
-    def is_connected(self) -> bool:
-        """Check if the gripper is connected and ready.
+    def get_position_mm(self) -> float | None:
+        """Return the last commanded position in mm, or None if unknown.
+
+        Returns the most recently set position. Subclasses that support
+        reading the actual hardware position should override this method.
+
+        Returns:
+            Position in mm, or None if not available.
+        """
+        return None
+
+    def max_travel_mm(self) -> float | None:
+        """Return the maximum finger travel in mm, or None if unknown.
 
         Returns:
-            True if the gripper is connected.
+            Max travel in mm, or None.
         """
+        return None
 
     @classmethod
     def create(cls, name: str, **kwargs) -> "Gripper":

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/gripper/digital.py

@@ -128,13 +128,3 @@ class DigitalGripper(Gripper):
         raise GripperError(
             "Digital grippers do not support set_speed."
         )
-
-    def is_connected(self) -> bool:
-        """Check if the gripper is connected.
-
-        Raises:
-            GripperError: Always — digital grippers can't verify connection.
-        """
-        raise GripperError(
-            "Digital grippers do not support connection checks."
-        )

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/gripper/robotiq.py

@@ -77,6 +77,7 @@ class RobotiqGripper(Gripper):
         self._force = force
         self._speed = speed
         self._activated = False
+        self._last_position_mm: float | None = None
 
         logger.info(
             "RobotiqGripper initialized (preamble, max_mm=%d)", max_mm
@@ -160,7 +161,7 @@ class RobotiqGripper(Gripper):
         """
         if self._activated:
             return
-        # Check activation state and activate+open if needed, all in one script.
+        # Check activation state and activate if needed.
         # rq_activate_and_wait() sends ACT then polls until the gripper
         # reports activated (~3-5s for internal initialization).
         activation_script = (
@@ -170,7 +171,6 @@ class RobotiqGripper(Gripper):
             + "if (not rq_is_gripper_activated()):\n"
             + "    rq_activate_and_wait()\n"
             + "end\n"
-            + "rq_open_and_wait()\n"
         )
         # Run in a thread with a timeout — the preamble blocks indefinitely
         # if no gripper is physically connected (2000-iteration loop).
@@ -204,10 +204,9 @@ class RobotiqGripper(Gripper):
     def deactivate(self) -> None:
         """Deactivate the gripper (send DEACT command).
 
+        Sends the Robotiq DEACT command to power down the gripper.
         Safe to call when not activated — becomes a no-op.
-        Use this before enabling freedrive to prevent the
-        gripper's script from interfering with manual movement.
-        Call activate() again after freedrive is disabled.
+        Call activate() again to re-enable the gripper.
         """
         if not self._activated:
             return
@@ -234,6 +233,7 @@ class RobotiqGripper(Gripper):
         self._require_activated()
         func = "rq_open_and_wait()" if wait else "rq_open()"
         self._send_script(self._build_script(func))
+        self._last_position_mm = float(self._max_mm)
         logger.debug("Robotiq gripper opened (wait=%s)", wait)
 
     def close(self, *, wait: bool = True) -> None:
@@ -250,6 +250,7 @@ class RobotiqGripper(Gripper):
         self._require_activated()
         func = "rq_close_and_wait()" if wait else "rq_close()"
         self._send_script(self._build_script(func))
+        self._last_position_mm = 0.0
         logger.debug("Robotiq gripper closed (wait=%s)", wait)
 
     def set_position(self, mm: float, *, wait: bool = True) -> None:
@@ -275,6 +276,7 @@ class RobotiqGripper(Gripper):
         else:
             func = f"rq_move_mm({mm})"
         self._send_script(self._build_script(func))
+        self._last_position_mm = mm
         logger.debug("Robotiq gripper set to %.1f mm (wait=%s)", mm, wait)
 
     def set_force(self, force: int) -> None:
@@ -303,15 +305,6 @@ class RobotiqGripper(Gripper):
         self._speed = speed
         logger.debug("Robotiq gripper speed set to %d", speed)
 
-    def is_connected(self) -> bool:
-        """Check if the gripper can send commands via RTDE."""
-        try:
-            return self._rtde.sendCustomScriptFunction(
-                "_grip_ping", 'textmsg("gripper", "ok")'
-            )
-        except Exception:
-            return False
-
     def disconnect(self) -> None:
         """Disconnect the gripper.
 
@@ -319,4 +312,18 @@ class RobotiqGripper(Gripper):
         using the gripper.
         """
         self._activated = False
+        self._last_position_mm = None
         logger.debug("Robotiq gripper disconnected")
+
+    def get_position_mm(self) -> float | None:
+        """Return the last commanded position in mm.
+
+        Returns:
+            Position in mm (0 = closed, max_mm = open), or None if
+            no position has been set yet.
+        """
+        return self._last_position_mm
+
+    def max_travel_mm(self) -> float:
+        """Return the maximum finger travel in mm."""
+        return float(self._max_mm)

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/motion.py

@@ -57,7 +57,7 @@ class FreedriveMode(IntEnum):
     """
 
     ALL = 0  # All 6 axes free
-    XYZ = 1  # Only linear axes (X, Y, Z)
+    XYZ = 1  # Linear axes (X, Y, Z) + rotation around Z (Rz)
     ROTATION = 2  # Only rotational axes (Roll, Pitch, Yaw)
 
 
@@ -475,7 +475,7 @@ class Motion:
             if mode == FreedriveMode.ALL:
                 free_axes = [1, 1, 1, 1, 1, 1]
             elif mode == FreedriveMode.XYZ:
-                free_axes = [1, 1, 1, 0, 0, 0]
+                free_axes = [1, 1, 1, 0, 0, 1]
             elif mode == FreedriveMode.ROTATION:
                 free_axes = [0, 0, 0, 1, 1, 1]
             else:

{urkit-0.1.0 → urkit-0.1.1}/src/urkit/robot.py

@@ -76,7 +76,6 @@ class URRobot:
             Presets provide mass, CoG, TCP offset, and backend type.
         default_vel: Default linear velocity (m/s).
         default_acc: Default linear acceleration (m/s²).
-        rtde_frequency: RTDE communication frequency in Hz (default 125).
         gripper_kwargs: Additional kwargs passed to the gripper backend
             to override preset values (e.g. ``max_mm=80`` for custom
             fingers, ``force=50``, ``speed=80`` for Robotiq).
@@ -97,13 +96,12 @@ class URRobot:
         gripper: GripperPreset | DigitalGripperConfig | None = None,
         default_vel: float = 0.5,
         default_acc: float = 0.3,
-        rtde_frequency: float = 125.0,
         **gripper_kwargs,
     ) -> None:
         self._ip = ip
         self._default_vel = default_vel
         self._default_acc = default_acc
-        self._rtde_frequency = rtde_frequency
+        self._rtde_frequency = 500.0
         self._connection_lost = False
         self._move_frame: MoveFrame = MoveFrame.BASE
 
@@ -298,7 +296,6 @@ class URRobot:
         gripper: GripperPreset | DigitalGripperConfig | str | None = None,
         default_vel: float | None = None,
         default_acc: float | None = None,
-        rtde_frequency: float | None = None,
         **gripper_kwargs,
     ) -> "URRobot":
         """Create a URRobot from a YAML config file or dict.
@@ -315,7 +312,6 @@ class URRobot:
                 or ``None``. Overrides the ``gripper`` key from config.
             default_vel: Default linear velocity (m/s).
             default_acc: Default linear acceleration (m/s²).
-            rtde_frequency: RTDE communication frequency in Hz.
             gripper_kwargs: Overrides for gripper preset values
                 (e.g. ``max_mm``, ``force``, ``speed``, ``pin``).
 
@@ -326,7 +322,7 @@ class URRobot:
             gripper: hand-e
             default_vel: 0.5
             default_acc: 0.3
-            rtde_frequency: 125
+            rtde_frequency: 500
 
         Example:
             >>> robot = URRobot.from_config("config.yaml")
@@ -394,7 +390,6 @@ class URRobot:
             gripper=resolved_gripper,
             default_vel=default_vel if default_vel is not None else cfg.get("default_vel", 0.5),
             default_acc=default_acc if default_acc is not None else cfg.get("default_acc", 0.3),
-            rtde_frequency=rtde_frequency if rtde_frequency is not None else cfg.get("rtde_frequency", 125.0),
             **gripper_kwargs,
         )
 

{urkit-0.1.0 → urkit-0.1.1}/src/urkit.egg-info/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: urkit
-Version: 0.1.0
+Version: 0.1.1
 Summary: Universal Robots e-Series control toolkit built on ur_rtde
 Author: URKit Contributors
 License: MIT
+Project-URL: Repository, https://github.com/rodolfo-verde/urkit
 Keywords: universal-robots,ur3e,ur5e,ur7e,ur10e,ur12e,ur16e,ur8,ur15,ur18,ur20,ur30,rtde,robotics,industrial-robot
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -25,6 +26,8 @@ Requires-Dist: rich>=13.0.0
 
 # URKit
 
+[![PyPI](https://img.shields.io/pypi/v/urkit.svg)](https://pypi.org/project/urkit/)
+
 **URKit** is a Python toolkit for [Universal Robots](https://www.universal-robots.com/) e-Series robots that makes the common stuff simple and gets out of the way for everything else.
 
 Built on [`ur_rtde`](https://sdurobotics.gitlab.io/ur_rtde/), it packages the operations you reach for most: connecting, moving to named points, gripper control, telemetry, and I/O, while exposing the raw RTDE interfaces for anything deeper. It doesn't try to replace `ur_rtde`; it sits on top of it so you can use both in tandem.
@@ -103,17 +106,20 @@ urkit teach                           # reads IP from config.yaml
 | Flag | Description |
 |------|-------------|
 | `ip` | Robot IP address (positional, overrides config) |
-| `--gripper` | Gripper preset: `2f-85`, `2f-140`, `hand-e`, `digital` |
+| `--gripper` | Gripper preset: `2f-85`, `2f-140`, `hand-e`, `digital`, `none` |
 | `--gripper-pin` | Digital gripper output pin (default: 0) |
 | `--gripper-force` | Robotiq force 0-100 |
 | `--gripper-speed` | Robotiq speed 0-100 |
 | `--gripper-close-on-high` | Digital polarity: `true` or `false` |
 | `--points` | Path to `points.db` file (overrides config) |
+| `--config` | Path to config file (default: `config.yaml` in project root or CWD) |
 | `-v`, `--verbose` | Show verbose output (debug connection issues) |
 
 ```bash
 urkit teach 172.31.1.200 --gripper hand-e --points /path/to/points.db
 urkit teach --gripper digital --gripper-pin 3
+urkit teach --gripper none            # no gripper (overrides config)
+urkit teach --config /path/to/my.yaml # load custom config
 urkit teach -v                        # verbose mode
 ```
 
@@ -210,10 +216,11 @@ All movement and orientation keys support **hold-to-repeat** — hold a key down
     <td align="center" style="width:50%">
       <table>
         <tr><th>Key</th><th>Action</th></tr>
-        <tr><td><code>F</code></td><td>Freedrive (OFF → ALL → XYZ)</td></tr>
+        <tr><td><code>F</code></td><td>Freedrive (OFF → ALL → XYZ+Rz)</td></tr>
         <tr><td><code>M</code></td><td>Toggle frame (BASE / TOOL)</td></tr>
         <tr><td><code>N</code></td><td>Go To mode (Cartesian / Joint)</td></tr>
         <tr><td><code>T</code></td><td>Orient TCP down (180°)</td></tr>
+        <tr><td><code>Y</code></td><td>Save config to file</td></tr>
         <tr><td><code>ESC</code></td><td>Exit</td></tr>
       </table>
     </td>
@@ -249,22 +256,110 @@ robot = URRobot(
 
 ### From Config
 
-Store your config in a `config.yaml`:
+```python
+robot = URRobot.from_config("config.yaml")
+robot = URRobot.from_config("config.yaml", ip="10.0.0.50")  # override IP
+```
+
+See the [Configuration](#configuration) section for full details on config location, keys, and saving.
+
+---
+
+## Configuration
+
+URKit uses a YAML config file (`config.yaml`) to persist settings between sessions. The CLI reads it automatically, and `URRobot.from_config()` loads it programmatically.
+
+### Config File Location
+
+URKit searches for `config.yaml` in this order:
+1. Explicit path via `--config` flag or `load_config("path")`
+2. Project root (where `src/urkit` lives)
+3. Current working directory
+
+If no config file exists, URKit uses built-in defaults and operates fine — the config is optional.
+
+### Config Keys
+
+| Key | Description | Example |
+|-----|-------------|---------|
+| `robot_ip` | Robot IP address | `192.168.1.100` |
+| `points_path` | Path to SQLite points database | `points.db` |
+| `gripper` | Gripper preset name | `hand-e`, `2f-85`, `2f-140`, `digital` |
+| `default_vel` | Default linear velocity (m/s) | `0.5` |
+| `default_acc` | Default linear acceleration (m/s²) | `0.3` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+| `rtde_frequency` | RTDE communication frequency (Hz) | `125` |
+
+### Gripper Config Section
+
+For digital grippers, specify pin and polarity:
+
+```yaml
+gripper: digital
+gripper_config:
+  pin: 3
+  close_on_high: true
+```
+
+For Robotiq grippers, override preset values:
 
 ```yaml
-robot_ip: 172.31.1.200
-points_path: points.db
 gripper: hand-e
-default_vel: 0.5
-default_acc: 0.3
-rtde_frequency: 125
+gripper_config:
+  force: 50
+  speed: 80
 ```
 
-Then load it:
+### CLI Override Precedence
+
+Settings are resolved in this order (highest priority first):
+
+1. **CLI flags** — `urkit teach 172.31.1.200 --gripper none`
+2. **Config file** — values from `config.yaml`
+3. **Built-in defaults** — `points.db` for points, no gripper, `0.5` m/s velocity
+
+Use `--gripper none` to explicitly disable a gripper that's set in your config file.
+
+### Saving Config
+
+The CLI **never** modifies your config file automatically. Inside the teach pendant, press **Y** to save your current session's settings (IP, gripper, points path) to the config file. This way you only save settings you've actually tested and verified work.
+
+```bash
+# First connection — test everything, then press Y inside the pendant
+urkit teach 172.31.1.200 --gripper hand-e
+
+# After pressing Y, config.yaml is saved. Next time:
+urkit teach                          # reads IP + gripper from config
+
+# Custom config file
+urkit teach --config station_a.yaml  # load from custom path
+# press Y inside → saves back to station_a.yaml
+```
+
+This lets you maintain separate configs per workcell:
+
+```bash
+urkit teach --config station_a.yaml  # press Y to save
+urkit teach --config station_b.yaml  # press Y to save
+```
+
+### Programmatic Config
 
 ```python
-robot = URRobot.from_config("config.yaml")
-robot = URRobot.from_config("config.yaml", ip="10.0.0.50")  # override IP
+from urkit import load_config, resolve_config
+
+# Load with auto-resolution
+config = load_config()  # searches for config.yaml
+config = load_config("/path/to/my.yaml")  # explicit path
+
+# Check if config exists
+path = resolve_config()  # returns Path or None
+
+# Create robot from config dict
+robot = URRobot.from_config({"robot_ip": "172.31.1.200", "gripper": "2f-85"})
 ```
 
 ---
@@ -478,7 +573,7 @@ from urkit import FreedriveMode
 
 # Freedrive lets you manually push the robot: motion commands won't work while active
 robot.enable_freedrive()              # all 6 axes free
-robot.enable_freedrive(FreedriveMode.XYZ)      # linear axes only
+robot.enable_freedrive(FreedriveMode.XYZ)      # linear axes + Rz rotation
 robot.enable_freedrive(FreedriveMode.ROTATION) # rotation only
 robot.disable_freedrive()             # always disable before sending motion commands
 

{urkit-0.1.0 → urkit-0.1.1}/tests/test_gripper.py

@@ -116,6 +116,49 @@ class TestRobotiqActivation:
         with pytest.raises(GripperError, match="not activated"):
             self.gripper.open()
 
+    def test_get_position_mm_initially_none(self):
+        """get_position_mm() returns None before any operation."""
+        assert self.gripper.get_position_mm() is None
+
+    def test_get_position_mm_after_activate(self):
+        """get_position_mm() returns None after activation (gripper doesn't open)."""
+        self.gripper.activate()
+        assert self.gripper.get_position_mm() is None
+
+    def test_get_position_mm_after_open(self):
+        """get_position_mm() returns max_mm after open()."""
+        self.gripper.activate()
+        self.gripper.open()
+        assert self.gripper.get_position_mm() == 50.0
+
+    def test_get_position_mm_after_close(self):
+        """get_position_mm() returns 0 after close()."""
+        self.gripper.activate()
+        self.gripper.close()
+        assert self.gripper.get_position_mm() == 0.0
+
+    def test_get_position_mm_after_set_position(self):
+        """get_position_mm() returns the commanded position."""
+        self.gripper.activate()
+        self.gripper.set_position(25)
+        assert self.gripper.get_position_mm() == 25.0
+
+    def test_get_position_mm_after_disconnect(self):
+        """get_position_mm() returns None after disconnect."""
+        self.gripper.activate()
+        self.gripper.set_position(30)
+        self.gripper.disconnect()
+        assert self.gripper.get_position_mm() is None
+
+    def test_max_travel_mm(self):
+        """max_travel_mm() returns the configured max_mm."""
+        assert self.gripper.max_travel_mm() == 50.0
+
+    def test_max_travel_mm_custom(self):
+        """max_travel_mm() returns the custom max_mm value."""
+        gripper = RobotiqGripper(rtde_control=self.rtde, max_mm=140)
+        assert gripper.max_travel_mm() == 140.0
+
 
 # ------------------------------------------------------------------
 # DigitalGripper activation tests
@@ -146,11 +189,6 @@ class TestDigitalActivation:
         gripper.close()
         mock_rtde.setStandardDigitalOut.assert_called_with(1, False)
 
-    def test_is_connected_raises(self, mock_rtde, mock_rtde_r):
-        gripper = DigitalGripper(mock_rtde, mock_rtde_r, pin=0)
-        with pytest.raises(GripperError, match="do not support connection"):
-            gripper.is_connected()
-
     def test_set_position_raises(self, mock_rtde, mock_rtde_r):
         gripper = DigitalGripper(mock_rtde, mock_rtde_r, pin=0)
         with pytest.raises(GripperError, match="do not support set_position"):

{urkit-0.1.0 → urkit-0.1.1}/tests/test_gripper_factory.py

@@ -78,13 +78,12 @@ class TestRobotiqGripper:
         self.gripper.activate()
         self.gripper.open()
         calls = self.rtde.sendCustomScriptFunction.call_args_list
-        # activate (combined check+activate+open) + open = 2 calls
+        # activate (check+activate only) + open = 2 calls
         assert len(calls) == 2
         # Check the activate call contains activation logic
         activate_code = calls[0][0][1]
         assert "rq_is_gripper_activated()" in activate_code
         assert "rq_activate_and_wait()" in activate_code
-        assert "rq_open_and_wait()" in activate_code
         # Check the open-after-activate call contains rq_open_and_wait
         open_code = calls[1][0][1]
         assert "rq_open_and_wait()" in open_code
@@ -131,9 +130,6 @@ class TestRobotiqGripper:
         second_count = self.rtde.sendCustomScriptFunction.call_count
         assert second_count - first_count == 1
 
-    def test_is_connected(self):
-        assert self.gripper.is_connected() is True
-
     def test_disconnect_resets_activation(self):
         """disconnect() resets activation flag; must call activate() again."""
         self.gripper.activate()