opentrons 8.7.0a9__py3-none-any.whl → 8.8.0a8__py3-none-any.whl

opentrons/hardware_control/modules/heater_shaker.py

@@ -2,19 +2,21 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Optional, Mapping
+from typing import Optional, Mapping, Callable
 from typing_extensions import Final
 
 from opentrons.drivers.rpi_drivers.types import USBPort
 from opentrons.drivers.heater_shaker.driver import HeaterShakerDriver
 from opentrons.drivers.heater_shaker.abstract import AbstractHeaterShakerDriver
 from opentrons.drivers.heater_shaker.simulator import SimulatingDriver
+from opentrons.drivers.asyncio.communication.errors import UnhandledGcode
 from opentrons.drivers.types import Temperature, RPM, HeaterShakerLabwareLatchStatus
 from opentrons.hardware_control.execution_manager import ExecutionManager
 from opentrons.hardware_control.poller import Reader, Poller
 from opentrons.hardware_control.modules import mod_abc, update
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
+    ModuleErrorCallback,
     ModuleType,
     TemperatureStatus,
     SpeedStatus,
@@ -47,12 +49,13 @@ class HeaterShaker(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
         poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "HeaterShaker":
         """
         Build a HeaterShaker
@@ -67,6 +70,7 @@ class HeaterShaker(mod_abc.AbstractModule):
             loop: Loop
             sim_model: The model name used by simulator
             disconnected_callback: Callback to inform the module controller that the device was disconnected
+            error_callback: Callback to inform the module controller of an asynchronous error
 
         Returns:
             HeaterShaker instance
@@ -91,6 +95,7 @@ class HeaterShaker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
 
         try:
@@ -109,8 +114,9 @@ class HeaterShaker(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Mapping[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
     ):
         super().__init__(
             port=port,
@@ -118,14 +124,22 @@ class HeaterShaker(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         self._device_info = device_info
         self._driver = driver
         self._reader = reader
         self._poller = poller
+        self._unsubscribe_reader = self._reader.register_error_handler(
+            self._handle_error
+        )
+
+    def _handle_error(self, error: Exception) -> None:
+        self.error_callback(error)
 
     async def cleanup(self) -> None:
         """Stop the poller task"""
+        self._unsubscribe_reader()
         await self._poller.stop()
         await self._driver.disconnect()
 
@@ -397,11 +411,22 @@ class HeaterShakerReader(Reader):
         self.labware_latch = HeaterShakerLabwareLatchStatus.IDLE_UNKNOWN
         self.error: Optional[str] = None
         self._driver = driver
+        self._handle_error: Callable[[Exception], None] | None = None
+
+    def register_error_handler(
+        self, handle_error: Callable[[Exception], None]
+    ) -> Callable[[], None]:
+        self._handle_error = handle_error
+        return self._unsubscribe_error_handler
+
+    def _unsubscribe_error_handler(self) -> None:
+        self._handle_error = None
 
     async def read(self) -> None:
         await self.read_temperature()
         await self.read_rpm()
         await self.read_labware_latch()
+        await self._read_errors()
         self._set_error(None)
 
     def on_error(self, exception: Exception) -> None:
@@ -420,7 +445,19 @@ class HeaterShakerReader(Reader):
         if exception is None:
             self.error = None
         else:
+            if self._handle_error:
+                self._handle_error(exception)
             try:
                 self.error = str(exception.args[0])
             except Exception:
                 self.error = repr(exception)
+
+    async def _read_errors(self) -> None:
+        try:
+            await self._driver.get_error_state()
+        except UnhandledGcode:
+            # This device's firmware cannot accept this command, because it
+            # hasn't been updated or because it's a gen1. Ignore the result.
+            pass
+        # If the error is one we should let pass, raise it so the top level
+        # error handler can take it.

opentrons/hardware_control/modules/magdeck.py

@@ -49,12 +49,13 @@ class MagDeck(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: types.ModuleDisconnectedCallback,
+        error_callback: types.ModuleErrorCallback,
         poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: types.ModuleDisconnectedCallback = None,
     ) -> "MagDeck":
         """Factory function."""
         driver: AbstractMagDeckDriver
@@ -73,6 +74,7 @@ class MagDeck(mod_abc.AbstractModule):
             device_info=await driver.get_device_info(),
             driver=driver,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         return mod
 
@@ -83,8 +85,9 @@ class MagDeck(mod_abc.AbstractModule):
         hw_control_loop: asyncio.AbstractEventLoop,
         driver: AbstractMagDeckDriver,
         device_info: Dict[str, str],
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: types.ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: types.ModuleDisconnectedCallback,
+        error_callback: types.ModuleErrorCallback,
     ) -> None:
         """Constructor"""
         super().__init__(
@@ -93,6 +96,7 @@ class MagDeck(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         self._device_info = device_info
         self._driver = driver

opentrons/hardware_control/modules/mod_abc.py

@@ -11,6 +11,7 @@ from ..execution_manager import ExecutionManager
 from .types import (
     BundledFirmware,
     ModuleDisconnectedCallback,
+    ModuleErrorCallback,
     UploadFunction,
     LiveData,
     ModuleType,
@@ -47,12 +48,13 @@ class AbstractModule(abc.ABC):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        poll_interval_seconds: Optional[float] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
+        poll_interval_seconds: float | None = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "AbstractModule":
         """Modules should always be created using this factory.
 
@@ -65,8 +67,9 @@ class AbstractModule(abc.ABC):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
     ) -> None:
         self._port = port
         self._usb_port = usb_port
@@ -75,6 +78,7 @@ class AbstractModule(abc.ABC):
         self._bundled_fw: Optional[BundledFirmware] = self.get_bundled_fw()
         self._disconnected_callback = disconnected_callback
         self._updating = False
+        self._error_callback = error_callback
 
     @staticmethod
     def sort_key(inst: "AbstractModule") -> int:
@@ -101,7 +105,11 @@ class AbstractModule(abc.ABC):
     def disconnected_callback(self) -> None:
         """Called from within the module object to signify the object is no longer connected"""
         if self._disconnected_callback is not None:
-            self._disconnected_callback(self.port, self.serial_number)
+            self._disconnected_callback(self.model(), self.port, self.serial_number)
+
+    def error_callback(self, exc: Exception) -> None:
+        """Called from within the module object when an asynchronous hardware error occurrs."""
+        self._error_callback(exc, self.model(), self.port, self.serial_number)
 
     def get_bundled_fw(self) -> Optional[BundledFirmware]:
         """Get absolute path to bundled version of module fw if available."""

opentrons/hardware_control/modules/tempdeck.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import asyncio
 import logging
-from typing import Dict, Optional
+from typing import Dict, Optional, Callable
 
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
+    ModuleErrorCallback,
     TemperatureStatus,
 )
 from opentrons.hardware_control.poller import Reader, Poller
@@ -38,12 +39,13 @@ class TempDeck(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
         poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "TempDeck":
         """
         Build a TempDeck
@@ -83,6 +85,7 @@ class TempDeck(mod_abc.AbstractModule):
             device_info=await driver.get_device_info(),
             hw_control_loop=hw_control_loop,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
 
         try:
@@ -101,8 +104,9 @@ class TempDeck(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Dict[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
     ) -> None:
         """Constructor"""
         super().__init__(
@@ -111,11 +115,13 @@ class TempDeck(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         self._device_info = device_info
         self._driver = driver
         self._reader = reader
         self._poller = poller
+        self._reader.set_error_callback(self.error_callback)
 
     async def cleanup(self) -> None:
         """Stop the poller task."""
@@ -293,7 +299,21 @@ class TempDeckReader(Reader):
     def __init__(self, driver: AbstractTempDeckDriver) -> None:
         self.temperature = Temperature(current=25, target=None)
         self._driver = driver
+        self._error_callback: Optional[Callable[[Exception], None]] = None
 
     async def read(self) -> None:
         """Read the module's current and target temperatures."""
         self.temperature = await self._driver.get_temperature()
+
+    def set_error_callback(
+        self, error_callback: Callable[[Exception], None]
+    ) -> Callable[[], None]:
+        self._error_callback = error_callback
+        return self._remove_error_callback
+
+    def _remove_error_callback(self) -> None:
+        self._error_callback = None
+
+    def on_error(self, exception: Exception) -> None:
+        if self._error_callback:
+            self._error_callback(exception)

opentrons/hardware_control/modules/thermocycler.py

@@ -9,6 +9,7 @@ from opentrons.hardware_control.modules.lid_temp_status import LidTemperatureSta
 from opentrons.hardware_control.modules.plate_temp_status import PlateTemperatureStatus
 from opentrons.hardware_control.modules.types import (
     ModuleDisconnectedCallback,
+    ModuleErrorCallback,
     TemperatureStatus,
 )
 from opentrons.hardware_control.poller import Reader, Poller
@@ -21,6 +22,7 @@ from opentrons.drivers.thermocycler import (
     ThermocyclerDriverV2,
     ThermocyclerDriverFactory,
 )
+from opentrons.drivers.asyncio.communication.errors import UnhandledGcode
 
 
 log = logging.getLogger(__name__)
@@ -36,6 +38,8 @@ DFU_PID = "df11"
 _TC_PLATE_LIFT_OPEN_DEGREES = 20
 _TC_PLATE_LIFT_RETURN_DEGREES = 23
 
+_TC_RAMP_RATE_ADDED_VERSION = (1, 0, 8)  # v1.0.8
+
 
 class ThermocyclerError(Exception):
     pass
@@ -62,12 +66,13 @@ class Thermocycler(mod_abc.AbstractModule):
         port: str,
         usb_port: USBPort,
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
         poll_interval_seconds: Optional[float] = None,
         simulating: bool = False,
         sim_model: Optional[str] = None,
         sim_serial_number: Optional[str] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
     ) -> "Thermocycler":
         """
         Build and connect to a Thermocycler
@@ -108,6 +113,7 @@ class Thermocycler(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
 
         try:
@@ -126,8 +132,9 @@ class Thermocycler(mod_abc.AbstractModule):
         poller: Poller,
         device_info: Dict[str, str],
         hw_control_loop: asyncio.AbstractEventLoop,
-        execution_manager: Optional[ExecutionManager] = None,
-        disconnected_callback: ModuleDisconnectedCallback = None,
+        execution_manager: ExecutionManager,
+        disconnected_callback: ModuleDisconnectedCallback,
+        error_callback: ModuleErrorCallback,
     ) -> None:
         """
         Constructor
@@ -150,6 +157,7 @@ class Thermocycler(mod_abc.AbstractModule):
             hw_control_loop=hw_control_loop,
             execution_manager=execution_manager,
             disconnected_callback=disconnected_callback,
+            error_callback=error_callback,
         )
         self._device_info = device_info
         self._reader = reader
@@ -159,10 +167,13 @@ class Thermocycler(mod_abc.AbstractModule):
         self._total_step_count: Optional[int] = None
         self._current_step_index: Optional[int] = None
         self._error: Optional[str] = None
-        self._reader.register_error_handler(self._enter_error_state)
+        self._unsubscribe_reader = self._reader.register_error_handler(
+            self._enter_error_state
+        )
 
     async def cleanup(self) -> None:
         """Stop the poller task."""
+        self._unsubscribe_reader()
         await self._poller.stop()
         await self._driver.disconnect()
 
@@ -265,6 +276,19 @@ class Thermocycler(mod_abc.AbstractModule):
         await self.open()
         await self._wait_for_lid_status(ThermocyclerLidStatus.OPEN)
 
+    def can_use_ramp_rate(self) -> bool:
+        version_string = self._device_info.get("version", "v")
+        if version_string.startswith("v"):
+            version_string = version_string[1:]
+        try:
+            version_tuple = tuple(int(c) for c in version_string.split("."))
+            return version_tuple >= _TC_RAMP_RATE_ADDED_VERSION
+        except (ValueError, IndexError):
+            log.error(
+                f"Invalid version from device: {self._device_info.get('version', '')}"
+            )
+            return False
+
     async def set_temperature(
         self,
         temperature: float,
@@ -290,6 +314,11 @@ class Thermocycler(mod_abc.AbstractModule):
 
         Returns: None
         """
+        if ramp_rate and not self.can_use_ramp_rate():
+            raise ThermocyclerError(
+                "Ramp rate is not supported by this thermocycler's firmware version, please update."
+            )
+
         await self.wait_for_is_running()
         await self._set_temperature_no_pause(
             temperature=temperature,
@@ -312,11 +341,13 @@ class Thermocycler(mod_abc.AbstractModule):
         total_seconds = seconds + (minutes * 60)
         hold_time = total_seconds if total_seconds > 0 else 0
 
-        if ramp_rate is not None:
-            await self._driver.set_ramp_rate(ramp_rate=ramp_rate)
+        if ramp_rate and not self.can_use_ramp_rate():
+            raise ThermocyclerError(
+                "Ramp rate is not supported by this thermocycler's firmware version, please update."
+            )
 
         await self._driver.set_plate_temperature(
-            temp=temperature, hold_time=hold_time, volume=volume
+            temp=temperature, hold_time=hold_time, volume=volume, ramp_rate=ramp_rate
         )
 
         task = self._loop.create_task(self._wait_for_block_target())
@@ -419,6 +450,7 @@ class Thermocycler(mod_abc.AbstractModule):
         celsius: float,
         hold_time_seconds: Optional[float] = None,
         volume: Optional[float] = None,
+        ramp_rate: Optional[float] = None,
     ) -> None:
         """Set the Thermocycler's target block temperature.
 
@@ -428,10 +460,17 @@ class Thermocycler(mod_abc.AbstractModule):
             celsius: The target block temperature, in degrees celsius.
         """
         await self.wait_for_is_running()
+
+        if ramp_rate and not self.can_use_ramp_rate():
+            raise ThermocyclerError(
+                "Ramp rate is not supported by this thermocycler's firmware version, please update."
+            )
+
         await self._driver.set_plate_temperature(
             temp=celsius,
             hold_time=hold_time_seconds,
             volume=volume,
+            ramp_rate=ramp_rate,
         )
         await self._reader.read_block_temperature()
 
@@ -596,11 +635,12 @@ class Thermocycler(mod_abc.AbstractModule):
         temperature = step.get("temperature")
         hold_time_minutes = step.get("hold_time_minutes", None)
         hold_time_seconds = step.get("hold_time_seconds", None)
+        ramp_rate = step.get("ramp_rate", None)
         await self._set_temperature_no_pause(
             temperature=temperature,  # type: ignore
             hold_time_minutes=hold_time_minutes,
             hold_time_seconds=hold_time_seconds,
-            ramp_rate=None,
+            ramp_rate=ramp_rate,
             volume=volume,
         )
 
@@ -672,7 +712,7 @@ class Thermocycler(mod_abc.AbstractModule):
             f"https://support.opentrons.com/en/articles/3469797-thermocycler-module"
             f" for troubleshooting."
         )
-        asyncio.run_coroutine_threadsafe(self.cleanup(), self._loop)
+        self.error_callback(error)
 
 
 class ThermocyclerReader(Reader):
@@ -710,14 +750,31 @@ class ThermocyclerReader(Reader):
         if self._handle_error is not None:
             self._handle_error(exception)
 
-    def register_error_handler(self, handle_error: Callable[[Exception], None]) -> None:
+    def register_error_handler(
+        self, handle_error: Callable[[Exception], None]
+    ) -> Callable[[], None]:
         self._handle_error = handle_error
+        return self._unsubscribe_error_handler
+
+    def _unsubscribe_error_handler(self) -> None:
+        self._handle_error = None
 
     async def read(self) -> None:
         """Poll the thermocycler."""
         await self.read_lid_status()
         await self.read_lid_temperature()
         await self.read_block_temperature()
+        await self._read_errors()
+
+    async def _read_errors(self) -> None:
+        try:
+            await self._driver.get_error_state()
+        except UnhandledGcode:
+            # This device's firmware cannot accept this command, because it
+            # hasn't been updated or because it's a gen1. Ignore the result.
+            pass
+        # If the error is one we should let pass, raise it so the top level
+        # error handler can take it.
 
     async def read_lid_status(self) -> None:
         self.lid_status = await self._driver.get_lid_status()

opentrons/hardware_control/modules/types.py

@@ -11,6 +11,7 @@ from typing import (
     Awaitable,
     Union,
     Optional,
+    Protocol,
     cast,
     TYPE_CHECKING,
     TypeGuard,
@@ -44,6 +45,7 @@ class ThermocyclerStepBase(TypedDict):
 class ThermocyclerStep(ThermocyclerStepBase, total=False):
     hold_time_seconds: float
     hold_time_minutes: float
+    ramp_rate: Optional[float]
 
 
 class ThermocyclerCycle(TypedDict):
@@ -54,7 +56,24 @@ class ThermocyclerCycle(TypedDict):
 UploadFunction = Callable[[str, str, Dict[str, Any]], Awaitable[Tuple[bool, str]]]
 
 
-ModuleDisconnectedCallback = Optional[Callable[[str, str | None], None]]
+class ModuleDisconnectedCallback(Protocol):
+    """Protocol for the callback when the module should be disconnected."""
+
+    def __call__(self, model: str, port: str, serial: str | None) -> None:
+        ...
+
+
+class ModuleErrorCallback(Protocol):
+    """Protocol for the callback when the module sees a hardware error."""
+
+    def __call__(
+        self,
+        exc: Exception,
+        model: str,
+        port: str,
+        serial: str | None,
+    ) -> None:
+        ...
 
 
 class MagneticModuleData(TypedDict):

opentrons/hardware_control/modules/utils.py

@@ -6,7 +6,12 @@ from opentrons.drivers.rpi_drivers.types import USBPort
 
 from ..execution_manager import ExecutionManager
 
-from .types import ModuleDisconnectedCallback, ModuleType, SpeedStatus
+from .types import (
+    ModuleDisconnectedCallback,
+    ModuleType,
+    SpeedStatus,
+    ModuleErrorCallback,
+)
 from .mod_abc import AbstractModule
 from .tempdeck import TempDeck
 from .magdeck import MagDeck
@@ -46,10 +51,11 @@ async def build(
     simulating: bool,
     usb_port: USBPort,
     hw_control_loop: asyncio.AbstractEventLoop,
-    execution_manager: Optional[ExecutionManager] = None,
+    execution_manager: ExecutionManager,
+    disconnected_callback: ModuleDisconnectedCallback,
+    error_callback: ModuleErrorCallback,
     sim_model: Optional[str] = None,
     sim_serial_number: Optional[str] = None,
-    disconnected_callback: ModuleDisconnectedCallback = None,
 ) -> AbstractModule:
     return await _MODULE_CLS_BY_TYPE[type].build(
         port=port,
@@ -57,9 +63,10 @@ async def build(
         simulating=simulating,
         hw_control_loop=hw_control_loop,
         execution_manager=execution_manager,
+        disconnected_callback=disconnected_callback,
+        error_callback=error_callback,
         sim_model=sim_model,
         sim_serial_number=sim_serial_number,
-        disconnected_callback=disconnected_callback,
     )
 
 

opentrons/hardware_control/motion_utilities.py

@@ -195,8 +195,7 @@ def target_position_from_plunger(
 def target_positions_from_plunger_tracking(
     mount: Union[Mount, OT3Mount],
     plunger_delta: float,
-    z_delta: float,
-    current_position: Dict[Axis, float],
+    end_position: OrderedDict[Axis, float],
 ) -> "OrderedDict[Axis, float]":
     """Create a target position for machine axes including plungers for dynamic liquid tracking.
 
@@ -206,10 +205,11 @@ def target_positions_from_plunger_tracking(
     volume to aspirate/dispense.
     z_delta: the distance to move the z axis- should be determined based on volume and well geometry.
     """
-    all_axes_pos = target_position_from_plunger(mount, plunger_delta, current_position)
-    z_ax = Axis.by_mount(mount)
-    all_axes_pos[z_ax] = current_position[z_ax] + z_delta
-    return all_axes_pos
+    plunger_pos = OrderedDict()
+    plunger = Axis.of_main_tool_actuator(mount)
+    plunger_pos[plunger] = plunger_delta
+    end_position.update(plunger_pos)
+    return end_position
 
 
 def deck_point_from_machine_point(

opentrons/hardware_control/nozzle_manager.py

@@ -77,6 +77,8 @@ class NozzleMap:
     #: A map of all of the nozzles of an instrument
     full_instrument_rows: Dict[str, List[str]]
     #: A map of all the rows of an instrument
+    full_instrument_columns: Dict[str, List[str]]
+    #: A map of all the columns of an instrument
 
     @classmethod
     def determine_nozzle_configuration(
@@ -299,6 +301,7 @@ class NozzleMap:
             rows=rows,
             full_instrument_map_store=physical_nozzles,
             full_instrument_rows=physical_rows,
+            full_instrument_columns=physical_columns,
             columns=columns,
             configuration=cls.determine_nozzle_configuration(
                 physical_rows, rows, physical_columns, columns