almond_axol.robot

from almond_axol.robot import Axol, AxolConfig, ArmConfig, JointConfig, FrictionParams, Jelly, JellyConfig, Sim

Axol(
    config: AxolConfig | None = None,        # None → the robot's shared settings
    left_channel: str | None = SHARED,       # SHARED → the robot.left_channel setting
    right_channel: str | None = SHARED,      # SHARED → the robot.right_channel setting
    left_joints: Iterable[Joint] | None = None,
    right_joints: Iterable[Joint] | None = None,
)

from almond_axol.settings import load_store, shared_axol_config, shared_config, shared_overlay
from almond_axol.robot import AxolConfig
from almond_axol.teleop.config import VRTeleopConfig

store = load_store()                          # ~/.almond/settings.json (or load_store(path))
config = shared_axol_config(store)            # AxolConfig as the panel would run it
teleop = shared_config(VRTeleopConfig, "teleop", "teleop", store=store)
overlay = shared_overlay("gravity-comp", store=store)   # nested dict of every value that applies to an op

import asyncio
import numpy as np
from almond_axol.robot import Axol

async def main():
    async with Axol() as axol:
        # non-blocking cached reads (fed by the core's 240 Hz telemetry)
        print("left positions (rad):", axol.left.positions)
        print("left torques (Nm):", axol.left.torques)

        # primary control: impedance for arm joints, position-force for gripper
        q = np.zeros(8, dtype=np.float32)
        q[7] = 1.0  # open gripper
        await axol.motion_control(left=q, right=q)

asyncio.run(main())

import asyncio
from almond_axol.robot import Axol

async def main():
    axol = Axol()
    await axol.connect()                   # open buses; nothing actuated
    held_l, held_r = await axol.get_holding()   # optional: inspect first
    await axol.enable()                    # holding joints kept holding

    # Resume from the *measured* pose — after a reconnect the arms are
    # wherever the previous session left them, and the max_step_rad safety
    # check is seeded against that pose, so a stale or default target is
    # rejected instead of yanking the arms.
    left, right = await axol.get_positions()
    await axol.motion_control(left=left, right=right)
    # ... ramp toward your desired target from here ...

    await axol.disconnect()                # exit, leaving torque as-is

asyncio.run(main())

from almond_axol.robot import Jelly, JellyConfig, detect_jelly

jelly = Jelly()                              # jelly.* from the shared settings file
jelly = Jelly(JellyConfig(max_speed=5.0))    # explicit config overrides it

cfg = detect_jelly(JellyConfig())            # only the attached wheels / lift
if cfg is not None:
    jelly = Jelly(cfg)

import asyncio
from almond_axol.robot import read_battery, read_power

async def main():
    battery = await read_battery()         # None if the lift board is silent
    if battery is not None:
        print(f"{battery.percent:.0f}% ({battery.voltage:.2f} V)")
        print(battery.charging, battery.under_load, battery.remaining_ah)

    power = await read_power()             # raw telemetry: rail volts, leg amps
    if power is not None:
        print(power.supply_volts, power.leg_currents)

asyncio.run(main())

import asyncio
import numpy as np
from almond_axol.robot import Sim

async def main():
    async with Sim(port=8002) as sim:
        q = np.zeros(8, dtype=np.float32)
        await sim.motion_control(left=q)
        await asyncio.sleep(float("inf"))  # keep the viser server alive

asyncio.run(main())

from almond_axol.robot import Axol, AxolConfig, FrictionParams

config = AxolConfig()
config.left.elbow.kp = 200
config.left.elbow.mass = 0.6
config.left.elbow.com = (-0.025, 0.0, -0.07)
config.left.elbow.friction = FrictionParams(fc=0.4, k=10.0, fv=0.05, fo=0.0)
async with Axol(config=config) as axol: ...

from dataclasses import replace
from almond_axol.robot import AxolConfig, JointConfig, FrictionParams

left = replace(
    AxolConfig().left,
    shoulder_1=JointConfig(
        kp=35.0, kd=1.2,
        friction=FrictionParams(fc=0.0, k=0.0, fv=0.0, fo=0.0),
        mass=2.0, com=(0.065, 0.0, 0.0),
    ),
)

config = AxolConfig()                                          # tuned gains (s=1, default)
config = AxolConfig(left_stiffness=0.5, right_stiffness=0.5)   # geometric mean: shoulder_1 kp = 100
config = AxolConfig(                                           # per-joint, left only
    left_stiffness=[1.0, 1.0, 0.8, 0.8, 0.5, 0.5, 0.2],
)

from almond_axol.robot import AxolConfig, Axol

config = AxolConfig()
config.left.elbow.mass = 0.6
config.left.elbow.com = (-0.025, 0.0, -0.07)
async with Axol(config=config) as axol: ...

import asyncio

from almond_axol.constants import GRIPPER_TIP_OFFSET
from almond_axol.robot import Axol


async def main() -> None:
    async with Axol() as axol:
        # ... close the left gripper on a 400 g part ...
        axol.set_payload("left", 0.4, GRIPPER_TIP_OFFSET)
        # ... carry it, then open the gripper ...
        axol.set_payload("left", 0.0)


asyncio.run(main())