# plan: [stages 1-3] card held; card aligned above slot; card seated and released # origin=fresh """A state-feedback program for the registered Franka/OSC GPU-install task. Only env.step(action) changes the world. No dataset, checkpoint, reset, state restoration, controller replacement, or scene-parameter writes are used. """ import json import math from pathlib import Path DART_SIGMA = 0.03 SOLVE_PARAMS = {'DART_SIGMA': None} ENTRIES = {'start': 'unassembled card upright in holder, hand free', 'preinsert': 'card genuinely held, above front entry, clear of all contacts'} def solve(env, entry=None, stop_after=None) -> None: import torch from isaaclab.utils.math import ( axis_angle_from_quat, quat_apply, quat_conjugate, quat_mul, ) params = json.loads(Path(__file__).with_name('parameters.json').read_text()) scene, robot = env.scene, env.robot art = robot.articulation dev, n = env.device, env.num_envs assert n == 1, 'This initial phase-1 delivery handles one environment per process' osc = robot.controller.controllers[0] assert type(osc).__name__ == 'OperationalSpaceController' assert robot.action_dim == 8 hand = art.body_names.index('panda_hand') dt = env.dt * robot.control_period offset = float(scene.GRASP_PINCH_OFFSET) zero = torch.zeros(3, device=dev) integral_p, integral_r = zero.clone(), zero.clone() steps = 0 active_phase = 'start' if entry not in (None, 'start', 'preinsert'): raise ValueError(entry) def v(values): return torch.tensor(values, device=dev, dtype=torch.float32) def mul(a,b): return quat_mul(a[None],b[None])[0] def inv(q): return quat_conjugate(q[None])[0] def rotate(q,x): return quat_apply(q[None],x[None])[0] def orientation_error(goal,current): if float(torch.dot(goal,current)) < 0: goal = -goal return axis_angle_from_quat(mul(goal, inv(current))[None])[0] def hp(): return art.data.body_pos_w[0,hand].clone() def hq(): return art.data.body_quat_w[0,hand].clone() def cp(): return scene.card.data.root_pos_w[0].clone() def cq(): return scene.card.data.root_quat_w[0].clone() def held(): return bool(scene.grasp_held[0].any()) def pinch(): return hp() + rotate(hq(),v([0,0,offset])) def band(): return cp()+rotate(cq(),v([-.020,sum(scene.CARD_BODY_Y)/2,.1005])) def log(phase,**extra): print('PHASE1 '+json.dumps(dict(phase=phase,steps=steps,seconds=steps*dt, held=held(),card=cp().tolist(),hand=hp().tolist(), offset=scene._card_offset_in_case()[0].tolist(), depth=float(scene.engaged()[0]),integral_position=integral_p.tolist(), integral_rotation=integral_r.tolist(),**extra)),flush=True) def tick(goal,quat,finger): nonlocal integral_p, integral_r, steps ep, er = goal-hp(), orientation_error(quat,hq()) integral_p=(integral_p+ep*dt).clamp(-.10,.10) integral_r=(integral_r+er*dt).clamp(-4.0,4.0) dp=ep+params['integral_position']*integral_p dr=er+params['integral_rotation']*integral_r dr=dr*min(1,2.5/max(float(dr.norm()),1e-9)) action=torch.zeros((1,8),device=dev) action[0,:3]=(dp/osc.cfg.pos_scale).clamp(-6,6) action[0,3:6]=(dr/osc.cfg.rot_scale).clamp(-20,20) action[0,6:]=finger # The preset smooths pose DELTAS, rather than absolute targets. Account # for its documented filter in the command; never write controller state. if params.get('compensate_action_filter',False) and osc._prev_action is not None: alpha=float(osc.cfg.ema_factor) action[0,:6]=(action[0,:6]-(1-alpha)*osc._prev_action[0])/alpha assert torch.isfinite(action).all() # Noise offered independently of noise_scale. Recorder keeps labels clean. disturbance = torch.zeros_like(action) if active_phase in ('lift_clear', 'transport_waypoint', 'above_case') and float(hp()[2]) > .38: disturbance[0, :3] = DART_SIGMA * torch.randn(3, device=dev) env.step(action, noise=disturbance) steps+=1 def move(goal_fn,grip,timeout,tag,tol=.002,rot_tol=.035,card_check=None): nonlocal active_phase active_phase = tag ref=hp(); good=0 for _ in range(max(1,math.ceil(timeout/dt))): goal,quat=goal_fn() delta=goal-ref; length=float(delta.norm()) ref=ref+delta*min(1,params['speed']*dt/max(length,1e-9)) tick(ref,quat,grip) goal,quat=goal_fn() ok=float((hp()-goal).norm())=8:log(tag,result='reached');return log(tag,result='timeout',position_error=float((hp()-goal).norm()),rotation_error=float(orientation_error(quat,hq()).norm())) raise RuntimeError('Stage did not reach its measured gate: '+tag) def hold(goal_fn,finger,seconds): nonlocal active_phase active_phase = 'hold' for _ in range(math.ceil(seconds/dt)): goal,quat=goal_fn();tick(goal,quat,finger) log('start') if entry != 'preinsert': # Stage 1: acquire the top band and verify a real grasp. down=[mul(cq(),v([0,0,1,0])),mul(cq(),v([0,1,0,0]))] pick_q=max(down,key=lambda q:abs(float(torch.dot(q,hq())))).clone() def pick_goal(height=0): return band()-rotate(pick_q,v([0,0,offset]))+v([0,0,height]),pick_q move(lambda:pick_goal(.10),.04,18,'above_card',tol=.004,rot_tol=.05) move(pick_goal,.04,16,'pinch_aligned',tol=.0025) for k in range(math.ceil(2/dt)): goal,quat=pick_goal() tick(goal,quat,.04+(.0172-.04)*min(1,(k+1)*dt/1.5)) hold(pick_goal,.0172,1) if not held():log('grasp_failed');raise RuntimeError('No grasp after controlled closure') log('card_held') elif not held(): raise RuntimeError('preinsert entry requires an actual grasp') rel_p=rotate(inv(hq()),cp()-hp()) rel_q=mul(inv(hq()),cq()) def card_goal(position,quat): # The grasp joint fixes this measured card-in-hand transform. A fixed # world-frame hand goal avoids moving the goal in response to its own lag. target_q=mul(quat,inv(rel_q)) return position-rotate(target_q,rel_p),target_q def case_point(local): return scene.case.data.root_pos_w[0]+rotate(scene.case.data.root_quat_w[0],v(local)) case_q=scene.case.data.root_quat_w[0].clone() seat=list(scene.cfg.seat_pos) forward=seat[0]+params['forward_clearance'] if entry != 'preinsert': lift=cp();lift[2]=float(scene.cfg.surface_z)+params['carry_height'] move(lambda:card_goal(lift,case_q),.0172,25,'lift_clear',tol=.003) if not held():raise RuntimeError('Grasp lost during lift') # Different plan: side staging stop, then transfer to the case entry. waypoint=cp(); waypoint[0]=.34; waypoint[1]=-.14 waypoint[2]=float(scene.cfg.surface_z)+params['carry_height'] move(lambda:card_goal(waypoint,case_q),.0172,30,'transport_waypoint',tol=.003) # Stage 2: enter forward of the rear panel, then slide through its cutout. high=[forward,seat[1],params['carry_height']-float(scene.cfg.case_lift)] move(lambda:card_goal(case_point(high),case_q),.0172,40,'above_case',tol=.003) if stop_after == 'above_case': return above=[forward,seat[1],float(scene.cfg.slot_mouth_z)+params['slide_height']] move(lambda:card_goal(case_point(above),case_q),.0172,20,'inside_case',tol=.002) aligned=[seat[0],seat[1],above[2]] def card_aligned(): return float((cp()-case_point(aligned)).norm())<.0007 and float(orientation_error(case_q,cq()).norm())<.004 move(lambda:card_goal(case_point(aligned),case_q),.0172,30,'slot_aligned',tol=.0004,rot_tol=.003,card_check=card_aligned) # Stage 3: press, release, retract, then leave the installed card unsupported. pressed=[seat[0],seat[1],seat[2]-.001] active_phase='press' press_z=aligned[2] for _ in range(math.ceil(25/dt)): press_z=max(pressed[2],press_z-params['press_speed']*dt) target,quat=card_goal(case_point([seat[0],seat[1],press_z]),case_q) tick(target,quat,.0172) if bool(scene.seated()[0]):break if not bool(scene.seated()[0]):log('press_failed');raise RuntimeError('Card did not seat') log('seated_before_release') keep=hp(); keep_q=hq() hold(lambda:(keep,keep_q),.04,2) up=keep+v([0,0,.14]) move(lambda:(up,keep_q),.04,16,'hand_clear',tol=.004,rot_tol=.06) hold(lambda:(up,keep_q),.04,5) log('finished',seated=bool(scene.seated()[0])) if held() or not bool(scene.seated()[0]):raise RuntimeError('Card did not remain seated after release')