pick up tip move happens, but rumbly

api/src/opentrons/config/defaults_ot3.py

@@ -104,7 +104,7 @@
  OT3AxisKind.Z: 150,
  OT3AxisKind.P: 30,
  OT3AxisKind.Z_G: 150,
- OT3AxisKind.Q: 10,
+ OT3AxisKind.Q: 4,
  },
  low_throughput={
  OT3AxisKind.X: 800,

api/src/opentrons/hardware_control/backends/ot3controller.py

@@ -81,6 +81,7 @@
 from opentrons_hardware.hardware_control.motor_position_status import (
  get_motor_position,
  update_motor_position_estimation,
+ update_gear_motor_position_estimation,
 )
 from opentrons_hardware.hardware_control.limit_switches import get_limit_switches
 from opentrons_hardware.hardware_control.tip_presence import get_tip_ejector_state

api/src/opentrons/hardware_control/backends/ot3utils.py

@@ -211,12 +211,10 @@ def get_current_settings(
  config: OT3CurrentSettings,
  gantry_load: GantryLoad,
 ) -> OT3AxisMap[CurrentConfig]:
- print(f"CONFIG = {config}")
  conf_by_pip = config.by_gantry_load(gantry_load)
- print(f"conf_by_pip = {conf_by_pip}")
  currents = {}
  for axis_kind in conf_by_pip["hold_current"].keys():
- for axis in Axis.of_kind(axis_kind):
+ for axis in OT3Axis.of_kind(axis_kind):
  currents[axis] = CurrentConfig(
  conf_by_pip["hold_current"][axis_kind],
  conf_by_pip["run_current"][axis_kind],
@@ -227,7 +225,7 @@ def get_current_settings(
 def get_system_constraints(
  config: OT3MotionSettings,
  gantry_load: GantryLoad,
-) -> "SystemConstraints[Axis]":
+) -> "SystemConstraints[OT3Axis]":
  conf_by_pip = config.by_gantry_load(gantry_load)
  constraints = {}
  axis_kind = [

api/src/opentrons/hardware_control/ot3api.py

@@ -1663,6 +1663,9 @@ async def _force_pick_up_tip(
  )
  await self._move(target_up)
 
+ async def get_gear_position(self):
+ return await self._backend.gear_motor_position_estimation()
+
  async def _motor_pick_up_tip(
  self, mount: OT3Mount, pipette_spec: TipMotorPickUpTipSpec
  ) -> None:
@@ -1679,25 +1682,32 @@ async def _motor_pick_up_tip(
  await self._move(target_down)
  # perform pick up tip
 
- gear_origin_dict = {OT3Axis.Q: 0}
+ # gear_origin_dict = {OT3Axis.Q: 0}
+ gear_motor_origin = await self._backend.gear_motor_position_estimation()
+ gear_origin_dict = {
+ OT3Axis.Q: gear_motor_origin[0]
+ }
  gear_motor_target = pipette_spec.pick_up_distance + pipette_spec.home_buffer
  gear_target_dict = {OT3Axis.Q: gear_motor_target}
  moves = self._build_moves(gear_origin_dict, gear_target_dict)
  blocks = moves[0][0].blocks
 
  for block in blocks:
+ print(f"block speed = {block.initial_speed}")
+ print(f"block acceleration = {block.acceleration}")
  await self._backend.tip_action(
  [OT3Axis.of_main_tool_actuator(mount)],
  block.distance,
- block.final_speed,
+ block.initial_speed,
  block.acceleration,
  "clamp",
  )
  # back clamps off the adapter posts
+ print(f"pipette spec speed = {pipette_spec.speed}")
  await self._backend.tip_action(
  [Axis.of_main_tool_actuator(mount)],
  pipette_spec.pick_up_distance + pipette_spec.home_buffer,
- pipette_spec.speed,
+ (pipette_spec.speed - 1),
  0,
  "home",
  )
@@ -1776,12 +1786,14 @@ async def drop_tip(
  [Axis.of_main_tool_actuator(mount)],
  move.target_position,
  move.speed,
+ 0,
  "clamp",
  )
  await self._backend.tip_action(
  [Axis.of_main_tool_actuator(mount)],
  move.target_position + move.home_buffer,
  move.speed,
+ 0,
  "home",
  )
  else:

api/src/opentrons/hardware_control/types.py

@@ -167,6 +167,7 @@ def of_kind(cls, kind: OT3AxisKind) -> List["Axis"]:
  OT3AxisKind.Z_G: [cls.Z_G],
  OT3AxisKind.Q: [cls.Q],
  OT3AxisKind.OTHER: [cls.Q],
+ # OT3AxisKind.OTHER: [cls.G],
  }
  return kind_map[kind]
 

api/tests/opentrons/hardware_control/test_ot3_api.py

@@ -1338,6 +1338,7 @@ async def test_save_instrument_offset(
  )
 
 
+
 async def test_pick_up_tip_full_tiprack(
  ot3_hardware: ThreadManager[OT3API],
  mock_instrument_handlers: Tuple[Mock],

hardware/opentrons_hardware/hardware_control/motor_position_status.py

@@ -17,6 +17,8 @@
  MotorPositionResponse,
  UpdateMotorPositionEstimationRequest,
  UpdateMotorPositionEstimationResponse,
+ UpdateGearMotorPositionEstimationRequest,
+ UpdateGearMotorPositionEstimationResponse,
 )
 from opentrons_hardware.firmware_bindings.arbitration_id import ArbitrationId
 from opentrons_hardware.firmware_bindings.constants import (
@@ -159,3 +161,66 @@ def _listener_filter(arbitration_id: ArbitrationId) -> bool:
  )
 
  return data
+
+
+async def update_gear_motor_position_estimation(
+ can_messenger: CanMessenger, timeout: float = 1.0
+) -> Tuple[float, bool]:
+ """Updates the estimation of motor position on selected nodes.
+
+ Request node to update motor position from its encoder and respond
+ with updated motor and encoder status.
+ """
+
+ def _listener_filter(arbitration_id: ArbitrationId) -> bool:
+ return (NodeId(arbitration_id.parts.originating_node_id) in {NodeId.pipette_left}) and (
+ MessageId(arbitration_id.parts.message_id)
+ == UpdateGearMotorPositionEstimationResponse.message_id
+ )
+
+ data = []
+
+ # for node in nodes:
+ with WaitableCallback(can_messenger, _listener_filter) as reader:
+ await can_messenger.send(
+ node_id=NodeId.pipette_left,
+ message=UpdateGearMotorPositionEstimationRequest(),
+ )
+ print(f"SENT GEAR MOTOR ESTIMATION REQUEST")
+ try:
+ for i in range(2):
+ response = await asyncio.wait_for(
+ _parser_update_gear_motor_position_response(
+ reader, NodeId.pipette_left
+ ),
+ timeout,
+ )
+ data.append(response)
+ # make sure response from both gear motors is the same
+ assert data[0] == data[1]
+ print(f"data = {data}")
+ if not data[0][1] or not data[1][1]:
+ # If the stepper_ok flag isn't set, that means the node didn't update position.
+ raise RuntimeError(
+ f"Failed to update motor position for node: {NodeId.pipette_left}"
+ )
+ except asyncio.TimeoutError:
+ log.warning("Update motor position estimation timed out")
+ raise StopAsyncIteration
+
+ return data[0]
+
+
+async def _parser_update_gear_motor_position_response(
+ reader: WaitableCallback, expected: NodeId
+) -> Tuple[float, bool]:
+ async for response, arb_id in reader:
+ print(f"\nGOT RESPONSE {response}\n")
+ assert isinstance(response, UpdateGearMotorPositionEstimationResponse)
+ node = NodeId(arb_id.parts.originating_node_id)
+ if node == expected:
+ return (
+ float(response.payload.current_position.value / 1000.0),
+ bool(MotorPositionFlags.stepper_position_ok.value),
+ )
+ raise StopAsyncIteration

hardware/opentrons_hardware/hardware_control/move_group_runner.py

@@ -99,7 +99,8 @@ def __init__(
  """
  self._move_groups = move_groups
  self._start_at_index = start_at_index
- self._ignore_stalls = ignore_stalls
+ # self._ignore_stalls = ignore_stalls
+ self._ignore_stalls = True
  self._is_prepped: bool = False
 
  @staticmethod