How to control the gripper while using IK controller?

[Yonggie]

I followed example of IK controller.py, and try to toggle the gripper of Fetch robot after ee moved to target position.
But it seems after IKSolver drive the robot ee to target pos, my code will suddenly make the robot lose all its force.

Also I tried to find gripper control at Fetch documentation, didn't work out.
How could I integrate gripper toggle on/off with IK controller?

ACT_GRIPPER_OPEN is extracted by keyboard control example

ACT_GRIPPER_OPEN=[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]
ACT_GRIPPER_CLOSE=[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., -1.]
 robot = env.robots[0]
    
    # Set robot base at the origin
    robot.set_position_orientation(position=th.tensor([0, 0, 0]), orientation=th.tensor([0, 0, 0, 1]))
    # At least one simulation step while the simulator is playing must occur for the robot (or in general, any object)
    # to be fully initialized after it is imported into the simulator
    og.sim.play()
    og.sim.step()
    # Make sure none of the joints are moving
    robot.keep_still()
    # Since this demo aims to showcase how users can directly control the robot with IK,
    # we will need to disable the built-in controllers in OmniGibson
    robot.control_enabled = False

    # Create the IK solver -- note that we are controlling both the trunk and the arm since both are part of the
    # controllable kinematic chain for the end-effector!
    control_idx = th.cat([th.from_numpy(robot.trunk_control_idx), th.from_numpy(robot.arm_control_idx[robot.default_arm])])
    ik_solver = IKSolver(
        robot_description_path=robot.robot_arm_descriptor_yamls[robot.default_arm],
        robot_urdf_path=robot.urdf_path,
        reset_joint_pos=robot.get_joint_positions()[control_idx],
        eef_name=robot.eef_link_names[robot.default_arm],
    )

    # Define a helper function for executing specific end-effector commands using the ik solver
    def execute_ik(pos, quat=None, max_iter=100):
        og.log.info("Querying joint configuration to current marker position")
        # Grab the joint positions in order to reach the desired pose target
        joint_pos = ik_solver.solve(
            target_pos=pos,
            target_quat=quat,
            tolerance_pos=0.002,
            tolerance_quat=0.01,
            weight_pos=20.0,
            weight_quat=0.05,
            max_iterations=max_iter,
            initial_joint_pos=robot.get_joint_positions()[control_idx],
        )
        if joint_pos is not None:
            og.log.info("Solution found. Setting new arm configuration.")
            robot.set_joint_positions(joint_pos, indices=control_idx, drive=True)
        else:
            og.log.info("EE position not reachable.")

        
        
        og.sim.step()
    
    
    marker = PrimitiveObject(
        relative_prim_path=f"/marker",
        name="marker",
        primitive_type="Sphere",
        radius=0.03,
        visual_only=True,
        rgba=[1.0, 0, 0, 1.0],
    )
    
    env.scene.add_object(marker, _is_call_from_simulator=True)
    

    # Get initial EE position and set marker to that location
    ee_pos = robot.get_eef_position()
    ee_quat=robot.get_eef_orientation()
    gripper_flag = 1
    marker.set_position_orientation(position=ee_pos)
    og.sim.step()

    # Setup callbacks for grabbing keyboard inputs from omni
    exit_now = False

    def keyboard_event_handler(event, *args, **kwargs):
        nonlocal ee_pos, ee_quat, exit_now, gripper_flag
        # Check if we've received a key press or repeat
        if (
            event.type == lazy.carb.input.KeyboardEventType.KEY_PRESS
            or event.type == lazy.carb.input.KeyboardEventType.KEY_REPEAT
        ):
            if event.input == lazy.carb.input.KeyboardInput.ENTER:
                # Execute the command
                execute_ik(pos=ee_pos,quat=ee_quat)
            elif event.input == lazy.carb.input.KeyboardInput.ESCAPE:
                # Quit
                og.log.info("Quit.")
                exit_now = True
            elif event.input == lazy.carb.input.KeyboardInput.U:
                # move ee pos ori
                gripper_flag= 1
                # update pos, ori
                ee_pos= ee_pos + 0
                ee_quat=add_delta_on_quat(ee_quat,delta_ori_eular)
                # update visualization
                marker.set_position_orientation(position=ee_pos,orientation=ee_quat)
                og.sim.step()
            elif event.input == lazy.carb.input.KeyboardInput.G:
# ==========my gripper control===============
                og.log.info(f'gripper flag {gripper_flag}')
                robot.control_enabled = True
                if gripper_flag>0.5:
                    gripper_act=ACT_GRIPPER_OPEN
                else:
                    gripper_act=ACT_GRIPPER_CLOSE
                
                for _ in range(10):
                    # env.step({'Fetch':gripper_act})
                    og.sim.step({'Fetch':gripper_act})
                robot.control_enabled = False
# ==========gripper control end================

        # Callback must return True if valid
        return True


    # Hook up the callback function with omni's user interface
    appwindow = lazy.omni.appwindow.get_default_app_window()
    input_interface = lazy.carb.input.acquire_input_interface()
    keyboard = appwindow.get_keyboard()
    sub_keyboard = input_interface.subscribe_to_keyboard_events(keyboard, keyboard_event_handler)

    # Print out helpful information to the user
    print_message()

    # Loop until the user requests an exit
    while not exit_now:
        og.sim.step()


    # Always shut the simulation down cleanly at the end
    og.clear()



if __name__ == "__main__":
    main()

[Yonggie]

Perhaps I should set the GRIPPER_CLOSE/OPEN action to be last action but with last element being -1/1? In this case how could I get the last action?