diff --git a/src/dodal/beamlines/i06_shared.py b/src/dodal/beamlines/i06_shared.py
index 891f91fee7d..3cf143375e8 100644
--- a/src/dodal/beamlines/i06_shared.py
+++ b/src/dodal/beamlines/i06_shared.py
@@ -1,11 +1,14 @@
 from dodal.common.beamlines.beamline_utils import set_beamline as set_utils_beamline
 from dodal.device_manager import DeviceManager
-from dodal.devices.beamlines.i06_shared import I06Grating
+from dodal.devices.beamlines.i06_shared import I06EpicsPolynomialDevice, I06Grating
+from dodal.devices.beamlines.i06_shared.i06_apple2_controller import I06Apple2Controller
 from dodal.devices.insertion_device import (
     Apple2,
+    InsertionDevicePolarisation,
     UndulatorGap,
     UndulatorLockedPhaseAxes,
 )
+from dodal.devices.insertion_device.energy import InsertionDeviceEnergy
 from dodal.devices.pgm import PlaneGratingMonochromator
 from dodal.devices.synchrotron import Synchrotron
 from dodal.log import set_beamline as set_log_beamline
@@ -24,6 +27,22 @@ def synchrotron() -> Synchrotron:
     return Synchrotron()
 
 
+@devices.factory()
+def pgm() -> PlaneGratingMonochromator:
+    return PlaneGratingMonochromator(
+        prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
+        grating=I06Grating,
+        grating_pv="NLINES2",
+    )
+
+
+# Insertion Device
+# ------------- Downstream Insertion Device --------------------
+@devices.factory()
+def i06_idd_epics_polynomial_device() -> I06EpicsPolynomialDevice:
+    return I06EpicsPolynomialDevice(prefix=f"{PREFIX.beamline_prefix}-OP-IDD-01:")
+
+
 @devices.factory()
 def idd_gap() -> UndulatorGap:
     return UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-01:")
@@ -44,6 +63,25 @@ def idd(idd_gap: UndulatorGap, idd_phase: UndulatorLockedPhaseAxes) -> Apple2:
     return Apple2(id_gap=idd_gap, id_phase=idd_phase)
 
 
+@devices.factory()
+def idd_controller(
+    idd: Apple2, i06_idd_epics_polynomial_device: I06EpicsPolynomialDevice
+) -> I06Apple2Controller:
+    """I06 downstream insertion device controller."""
+    return I06Apple2Controller(
+        apple2=idd,
+        gap_energy_motor_lut=i06_idd_epics_polynomial_device.energy_gap_motor_lookup,
+        phase_energy_motor_lut=i06_idd_epics_polynomial_device.energy_phase_motor_lookup,  # need fix this too
+        gap_motor_energy_lut=i06_idd_epics_polynomial_device.gap_motor_energy_lookup,
+    )
+
+
+# -------------------- Upstream Insertion Device -------------------
+@devices.factory()
+def i06_idu_epics_polynomial_device() -> I06EpicsPolynomialDevice:
+    return I06EpicsPolynomialDevice(prefix=f"{PREFIX.beamline_prefix}-OP-IDU-01:")
+
+
 @devices.factory()
 def idu_gap() -> UndulatorGap:
     return UndulatorGap(prefix=f"{PREFIX.insertion_prefix}-MO-SERVC-21:")
@@ -65,9 +103,25 @@ def idu(idu_gap: UndulatorGap, idu_phase: UndulatorLockedPhaseAxes) -> Apple2:
 
 
 @devices.factory()
-def pgm() -> PlaneGratingMonochromator:
-    return PlaneGratingMonochromator(
-        prefix=f"{PREFIX.beamline_prefix}-OP-PGM-01:",
-        grating=I06Grating,
-        grating_pv="NLINES2",
+def idu_controller(
+    idu: Apple2, i06_idu_epics_polynomial_device: I06EpicsPolynomialDevice
+) -> I06Apple2Controller:
+    """I06 upstream insertion device controller."""
+    return I06Apple2Controller(
+        apple2=idu,
+        gap_energy_motor_lut=i06_idu_epics_polynomial_device.energy_gap_motor_lookup,
+        phase_energy_motor_lut=i06_idu_epics_polynomial_device.energy_phase_motor_lookup,
+        gap_motor_energy_lut=i06_idu_epics_polynomial_device.gap_motor_energy_lookup,
     )
+
+
+@devices.factory()
+def idu_energy(idu_controller: I06Apple2Controller) -> InsertionDeviceEnergy:
+    return InsertionDeviceEnergy(id_controller=idu_controller)
+
+
+@devices.factory()
+def idu_polarisation(
+    idu_controller: I06Apple2Controller,
+) -> InsertionDevicePolarisation:
+    return InsertionDevicePolarisation(id_controller=idu_controller)
diff --git a/src/dodal/devices/beamlines/i05_shared/apple_knot_constants.py b/src/dodal/devices/beamlines/i05_shared/apple_knot_constants.py
index 72720c09a1e..432a92a9de2 100644
--- a/src/dodal/devices/beamlines/i05_shared/apple_knot_constants.py
+++ b/src/dodal/devices/beamlines/i05_shared/apple_knot_constants.py
@@ -70,23 +70,23 @@
 )
 
 
-def energy_to_gap_converter(energy: float, pol: Pol) -> float:
+def energy_to_gap_converter(value: float, pol: Pol) -> float:
     if pol == Pol.LH:
-        return float(LH_GAP_POLYNOMIAL(energy))
+        return float(LH_GAP_POLYNOMIAL(value))
     if pol == Pol.LV:
-        return float(LV_GAP_POLYNOMIAL(energy))
+        return float(LV_GAP_POLYNOMIAL(value))
     if pol == Pol.PC or pol == Pol.NC:
-        return float(C_GAP_POLYNOMIAL(energy))
+        return float(C_GAP_POLYNOMIAL(value))
     return 0.0
 
 
-def energy_to_phase_converter(energy: float, pol: Pol) -> float:
+def energy_to_phase_converter(value: float, pol: Pol) -> float:
     if pol == Pol.LH:
         return 0.0
     if pol == Pol.LV:
         return 70.0
     if pol == Pol.PC:
-        return float(C_PHASE_POLYNOMIAL(energy))
+        return float(C_PHASE_POLYNOMIAL(value))
     if pol == Pol.NC:
-        return -float(C_PHASE_POLYNOMIAL(energy))
+        return -float(C_PHASE_POLYNOMIAL(value))
     return 0.0
diff --git a/src/dodal/devices/beamlines/i06_shared/__init__.py b/src/dodal/devices/beamlines/i06_shared/__init__.py
index 0595989bbe5..72d2203aab8 100644
--- a/src/dodal/devices/beamlines/i06_shared/__init__.py
+++ b/src/dodal/devices/beamlines/i06_shared/__init__.py
@@ -1,3 +1,5 @@
+from .i06_apple2_controller import I06Apple2Controller
 from .i06_enum import I06Grating
+from .i06_epics_lookup import I06EpicsPolynomialDevice
 
-__all__ = ["I06Grating"]
+__all__ = ["I06Grating", "I06EpicsPolynomialDevice", "I06Apple2Controller"]
diff --git a/src/dodal/devices/beamlines/i06_shared/i06_apple2_controller.py b/src/dodal/devices/beamlines/i06_shared/i06_apple2_controller.py
new file mode 100644
index 00000000000..7120d9690f9
--- /dev/null
+++ b/src/dodal/devices/beamlines/i06_shared/i06_apple2_controller.py
@@ -0,0 +1,61 @@
+from dodal.devices.insertion_device import (
+    Apple2,
+    Apple2Controller,
+    Apple2PhasesVal,
+    Apple2Val,
+    Pol,
+    UndulatorPhaseAxes,
+)
+from dodal.devices.insertion_device.energy_motor_lookup import EnergyMotorLookup
+
+ROW_PHASE_MOTOR_TOLERANCE = 0.004
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+MAXIMUM_GAP_MOTOR_POSITION = 100
+DEFAULT_JAW_PHASE_POLY_PARAMS = [1.0 / 7.5, -120.0 / 7.5]
+
+
+class I06Apple2Controller(Apple2Controller[Apple2[UndulatorPhaseAxes]]):
+    """I17Apple2Controller is a extension of Apple2Controller which provide linear
+    arbitrary angle control.
+
+    Args:
+        apple2 (Apple2): An Apple2 device.
+        gap_energy_motor_lut (EnergyMotorLookup): The class that handles the gap
+            look up table logic for the insertion device.
+        phase_energy_motor_lut (EnergyMotorLookup): The class that handles the phase
+            look up table logic for the insertion device.
+        units (str, optional): The units of this device. Defaults to eV.
+        name (str, optional): New device name.
+    """
+
+    def __init__(
+        self,
+        apple2: Apple2[UndulatorPhaseAxes],
+        gap_energy_motor_lut: EnergyMotorLookup,
+        phase_energy_motor_lut: EnergyMotorLookup,
+        gap_motor_energy_lut: EnergyMotorLookup,
+        units: str = "eV",
+        name: str = "",
+    ) -> None:
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
+        self.gap_motor_energy_lut = gap_motor_energy_lut
+        super().__init__(
+            apple2=apple2,
+            gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
+            phase_energy_motor_converter=phase_energy_motor_lut.find_value_in_lookup_table,
+            gap_motor_energy_converter=gap_motor_energy_lut.find_value_in_lookup_table,
+            units=units,
+            name=name,
+        )
+
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        return Apple2Val(
+            gap=gap,
+            phase=Apple2PhasesVal(
+                top_outer=phase,
+                top_inner=0.0,
+                btm_inner=phase,
+                btm_outer=0.0,
+            ),
+        )
diff --git a/src/dodal/devices/beamlines/i06_shared/i06_epics_lookup.py b/src/dodal/devices/beamlines/i06_shared/i06_epics_lookup.py
new file mode 100644
index 00000000000..a3c300de404
--- /dev/null
+++ b/src/dodal/devices/beamlines/i06_shared/i06_epics_lookup.py
@@ -0,0 +1,141 @@
+import asyncio
+
+from bluesky.protocols import Triggerable
+from ophyd_async.core import AsyncStatus, Device, DeviceMock, DeviceVector
+from ophyd_async.epics.core import epics_signal_rw
+
+from dodal.device_manager import DEFAULT_TIMEOUT
+from dodal.devices.insertion_device import (
+    EnergyCoverage,
+    EnergyMotorLookup,
+    LookupTable,
+    Pol,
+)
+from dodal.log import LOGGER
+
+ROW_PHASE_CIRCULAR = 15.0
+MAXIMUM_ROW_PHASE_MOTOR_POSITION = 24.0
+DEFAULT_POLY1D_PARAMETERS = {
+    Pol.LH: [0],
+    Pol.LV: [MAXIMUM_ROW_PHASE_MOTOR_POSITION],
+    Pol.PC: [ROW_PHASE_CIRCULAR],
+    Pol.PC3: [ROW_PHASE_CIRCULAR],
+    Pol.NC: [-ROW_PHASE_CIRCULAR],
+    Pol.NC3: [-ROW_PHASE_CIRCULAR],
+}
+
+
+class I06EpicsPolynomialDevice(Device, Triggerable):
+    def __init__(
+        self,
+        prefix: str,
+        max_energy: float = 2200,
+        min_energy: float = 70,
+        name: str = "",
+    ) -> None:
+        # Define mapping of polarization to PV suffix
+        self._pol_map = {
+            Pol.LH: "HZ",
+            Pol.LV: "VT",
+            Pol.PC: "PC",
+            Pol.NC: "NC",
+            Pol.PC3: "PC:HAR3",
+            Pol.NC3: "NC:HAR3",
+        }
+        self._inv_pol_map = {
+            Pol.LH: "BHZ",
+            Pol.LV: "BVT",
+            Pol.PC: "BPC",
+            Pol.NC: "BNC",
+            Pol.PC3: "BPC:HAR3",
+            Pol.NC3: "BNC:HAR3",
+        }
+        self.param_dict = {}
+        self.inv_param_dict = {}
+        self.min_energy = min_energy
+        self.max_energy = max_energy
+        # Initialize DeviceVectors
+        for pol, suffix in self._inv_pol_map.items():
+            attr_name = f"{pol.name.lower()}_inverse_params"
+            setattr(self, attr_name, self._make_params(f"{prefix}{suffix}"))
+            self.inv_param_dict[pol] = getattr(self, attr_name)
+
+        for pol, suffix in self._pol_map.items():
+            attr_name = f"{pol.name.lower()}_params"
+            setattr(self, attr_name, self._make_params(f"{prefix}{suffix}"))
+            self.param_dict[pol] = getattr(self, attr_name)
+        self.energy_gap_motor_lookup = EnergyMotorLookup()
+        self.energy_phase_motor_lookup = EnergyMotorLookup()
+        self.gap_motor_energy_lookup = EnergyMotorLookup()
+        super().__init__(name=name)
+
+    def _make_params(self, pv_prefix: str) -> DeviceVector:
+        return DeviceVector(
+            {
+                i: epics_signal_rw(float, read_pv=f"{pv_prefix}:C{i}")
+                for i in range(12, 0, -1)
+            }
+        )
+
+    @AsyncStatus.wrap
+    async def trigger(self) -> None:
+        """Triggering this device will update the lookup tables with the current PV values."""
+        await self.update_lookup()
+
+    async def _get_table_entries(
+        self,
+        param_dict: dict[Pol, DeviceVector | list[float]],
+        min_energy: float,
+        max_energy: float,
+    ) -> dict[Pol, EnergyCoverage]:
+        entries = {}
+        for pol, vector in param_dict.items():
+            if isinstance(vector, DeviceVector):
+                coeffs = await asyncio.gather(*(p.get_value() for p in vector.values()))
+            else:
+                coeffs = vector
+            entries[pol] = EnergyCoverage.generate(
+                min_energies=[min_energy],
+                max_energies=[max_energy],
+                poly1d_params=[coeffs],
+            )
+        return entries
+
+    async def update_lookup(self) -> None:
+        # Update gap lookup table
+        energy_entries = await self._get_table_entries(
+            self.param_dict, self.min_energy, self.max_energy
+        )
+        self.energy_gap_motor_lookup = EnergyMotorLookup(LookupTable(energy_entries))
+        # find gap range from energy range
+        min_gap = self.energy_gap_motor_lookup.find_value_in_lookup_table(
+            value=self.max_energy, pol=Pol.LH
+        )
+        max_gap = self.energy_gap_motor_lookup.find_value_in_lookup_table(
+            value=self.min_energy, pol=Pol.LH
+        )
+        # Update gap inverse lookup table
+        inv_energy_entries = await self._get_table_entries(
+            self.inv_param_dict, max_energy=max_gap, min_energy=min_gap
+        )
+        self.gap_motor_energy_lookup = EnergyMotorLookup(
+            LookupTable(inv_energy_entries)
+        )
+        # Update phase lookup table
+        energy_entries = await self._get_table_entries(
+            DEFAULT_POLY1D_PARAMETERS, max_energy=max_gap, min_energy=min_gap
+        )
+        self.energy_phase_motor_lookup = EnergyMotorLookup(LookupTable(energy_entries))
+        LOGGER.info("Updating lookup tables with new values from EPICS.")
+
+    async def connect(
+        self,
+        mock: bool | DeviceMock = False,
+        timeout: float = DEFAULT_TIMEOUT,
+        force_reconnect: bool = False,
+    ) -> None:
+        await super().connect(
+            mock=mock, timeout=timeout, force_reconnect=force_reconnect
+        )
+        # Highjack connect to update lookup tables on connection.
+        await self.update_lookup()
diff --git a/src/dodal/devices/insertion_device/__init__.py b/src/dodal/devices/insertion_device/__init__.py
index 0dc4f938b7a..48931a70f6f 100644
--- a/src/dodal/devices/insertion_device/__init__.py
+++ b/src/dodal/devices/insertion_device/__init__.py
@@ -30,6 +30,7 @@
 from .enum import Pol, UndulatorGateStatus
 from .lookup_table_models import (
     EnergyCoverage,
+    EnergyCoverageEntry,
     LookupTable,
     LookupTableColumnConfig,
     convert_csv_to_lookup,
@@ -67,4 +68,5 @@
     "EnergyMotorConvertor",
     "UnstoppableMotor",
     "InsertionDeviceEnergyBase",
+    "EnergyCoverageEntry",
 ]
diff --git a/src/dodal/devices/insertion_device/apple2_controller.py b/src/dodal/devices/insertion_device/apple2_controller.py
index 8d5a17db581..c6750886d9f 100644
--- a/src/dodal/devices/insertion_device/apple2_controller.py
+++ b/src/dodal/devices/insertion_device/apple2_controller.py
@@ -32,8 +32,8 @@
 
 
 class EnergyMotorConvertor(Protocol):
-    def __call__(self, energy: float, pol: Pol) -> float:
-        """Protocol to provide energy to motor position conversion."""
+    def __call__(self, value: float, pol: Pol) -> float:
+        """Protocol to provide energy, motor position conversion."""
         ...
 
 
@@ -94,6 +94,7 @@ def __init__(
         apple2: Apple2Type,
         gap_energy_motor_converter: EnergyMotorConvertor,
         phase_energy_motor_converter: EnergyMotorConvertor,
+        gap_motor_energy_converter: EnergyMotorConvertor | None = None,
         maximum_gap_motor_position: float = MAXIMUM_GAP_MOTOR_POSITION,
         maximum_phase_motor_position: float = MAXIMUM_ROW_PHASE_MOTOR_POSITION,
         units: str = "eV",
@@ -102,20 +103,12 @@ def __init__(
         self.apple2 = Reference(apple2)
         self.gap_energy_motor_converter = gap_energy_motor_converter
         self.phase_energy_motor_converter = phase_energy_motor_converter
+        self.gap_motor_energy_converter = gap_motor_energy_converter
 
         self.maximum_gap_motor_position = maximum_gap_motor_position
         self.maximum_phase_motor_position = maximum_phase_motor_position
         # Store the set energy for readback.
-        self._energy, self._energy_set = soft_signal_r_and_setter(
-            float, initial_value=None, units=units
-        )
-        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
-            self.energy = derived_signal_rw(
-                raw_to_derived=self._read_energy,
-                set_derived=self._set_energy,
-                energy=self._energy,
-                derived_units=units,
-            )
+        self._energy = soft_signal_rw(float, initial_value=100)
 
         # Store the polarisation for setpoint. And provide readback for LH3.
         # LH3 is a special case as it is indistinguishable from LH in the hardware.
@@ -144,6 +137,16 @@ def __init__(
                 btm_outer=btm_outer,
                 gap=self.apple2().gap().user_readback,
             )
+        with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL):
+            self.energy = derived_signal_rw(
+                raw_to_derived=self._read_energy,
+                set_derived=self._set_energy,
+                energy=self._energy,
+                pol=self.polarisation,
+                gap=self.apple2().gap().user_readback,
+                derived_units=units,
+            )
+
         super().__init__(name)
 
     @abc.abstractmethod
@@ -157,8 +160,8 @@ async def _set_motors_from_energy_and_polarisation(
         self, energy: float, pol: Pol
     ) -> None:
         """Set the undulator motors for a given energy and polarisation."""
-        gap = self.gap_energy_motor_converter(energy=energy, pol=pol)
-        phase = self.phase_energy_motor_converter(energy=energy, pol=pol)
+        gap = self.gap_energy_motor_converter(value=energy, pol=pol)
+        phase = self.phase_energy_motor_converter(value=energy, pol=pol)
         apple2_val = self._get_apple2_value(gap, phase, pol)
         LOGGER.info(f"Setting polarisation to {pol}, with values: {apple2_val}")
         await self.apple2().set(id_motor_values=apple2_val)
@@ -166,10 +169,12 @@ async def _set_motors_from_energy_and_polarisation(
     async def _set_energy(self, energy: float) -> None:
         pol = await self._check_and_get_pol_setpoint()
         await self._set_motors_from_energy_and_polarisation(energy, pol)
-        self._energy_set(energy)
+        await self._energy.set(energy)
 
-    def _read_energy(self, energy: float) -> float:
-        """Readback for energy is just the set value."""
+    def _read_energy(self, energy: float, pol: Pol, gap: float) -> float:
+        """Readback for energy is just the set value if there is no inverse converter."""
+        if self.gap_motor_energy_converter is not None:
+            energy = self.gap_motor_energy_converter(value=gap, pol=pol)
         return energy
 
     async def _check_and_get_pol_setpoint(self) -> Pol:
@@ -197,7 +202,7 @@ async def _set_pol(
     ) -> None:
         # This changes the pol setpoint and then changes polarisation via set energy.
         self._polarisation_setpoint_set(value)
-        await self.energy.set(await self.energy.get_value(), timeout=MAXIMUM_MOVE_TIME)
+        await self.energy.set(await self._energy.get_value(), timeout=MAXIMUM_MOVE_TIME)
 
     def _read_pol(
         self,
@@ -247,57 +252,38 @@ def determine_phase_from_hardware(
                 f"{self.name} is not in use, close gap or set polarisation to use this ID"
             )
 
-        if all(
-            isclose(x, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            for x in [top_outer, top_inner, btm_inner, btm_outer]
-        ):
+        tol = ROW_PHASE_MOTOR_TOLERANCE
+        max_p = self.maximum_phase_motor_position
+
+        zero = {
+            "to": isclose(top_outer, 0.0, abs_tol=tol),
+            "ti": isclose(top_inner, 0.0, abs_tol=tol),
+            "bi": isclose(btm_inner, 0.0, abs_tol=tol),
+            "bo": isclose(btm_outer, 0.0, abs_tol=tol),
+        }
+
+        if all(zero.values()):
             LOGGER.info("Determined polarisation: LH (Linear Horizontal).")
             return Pol.LH, 0.0
         if (
-            isclose(
-                top_outer,
-                btm_inner,
-                abs_tol=ROW_PHASE_MOTOR_TOLERANCE,
-            )
-            and isclose(top_inner, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(btm_outer, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(
-                abs(btm_inner),
-                self.maximum_phase_motor_position,
-                abs_tol=ROW_PHASE_MOTOR_TOLERANCE,
-            )
+            isclose(top_outer, btm_inner, abs_tol=tol)
+            and isclose(abs(top_outer), max_p, abs_tol=tol)
+            and zero["ti"]
+            and zero["bo"]
         ):
             LOGGER.info("Determined polarisation: LV (Linear Vertical).")
-            return Pol.LV, self.maximum_phase_motor_position
-        if (
-            isclose(top_outer, btm_inner, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and top_outer > 0.0
-            and isclose(top_inner, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(btm_outer, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-        ):
-            LOGGER.info("Determined polarisation: PC (Positive Circular).")
-            return Pol.PC, top_outer
-        if (
-            isclose(top_outer, btm_inner, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and top_outer < 0.0
-            and isclose(top_inner, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(btm_outer, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-        ):
-            LOGGER.info("Determined polarisation: NC (Negative Circular).")
-            return Pol.NC, top_outer
-        if (
-            isclose(top_outer, -btm_inner, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(top_inner, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(btm_outer, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-        ):
-            LOGGER.info("Determined polarisation: LA (Positive Linear Arbitrary).")
+            return Pol.LV, max_p
+        if isclose(top_outer, btm_inner, abs_tol=tol) and zero["ti"] and zero["bo"]:
+            pol = Pol.PC if top_outer > 0 else Pol.NC
+            LOGGER.info(f"Determined polarisation: {pol}.")
+            return pol, top_outer
+
+        if isclose(top_outer, -btm_inner, abs_tol=tol) and zero["ti"] and zero["bo"]:
+            LOGGER.info("Determined polarisation: LA.")
             return Pol.LA, top_outer
-        if (
-            isclose(top_inner, -btm_outer, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(top_outer, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-            and isclose(btm_inner, 0.0, abs_tol=ROW_PHASE_MOTOR_TOLERANCE)
-        ):
-            LOGGER.info("Determined polarisation: LA (Negative Linear Arbitrary).")
+
+        if isclose(top_inner, -btm_outer, abs_tol=tol) and zero["to"] and zero["bi"]:
+            LOGGER.info("Determined polarisation: LA.")
             return Pol.LA, top_inner
 
         LOGGER.warning("Unable to determine polarisation. Defaulting to NONE.")
@@ -322,8 +308,8 @@ def __init__(
         units: str = "eV",
         name: str = "",
     ) -> None:
-        self.gap_energy_motor_lu = gap_energy_motor_lut
-        self.phase_energy_motor_lu = phase_energy_motor_lut
+        self.gap_energy_motor_lut = gap_energy_motor_lut
+        self.phase_energy_motor_lut = phase_energy_motor_lut
         super().__init__(
             apple2=apple2,
             gap_energy_motor_converter=gap_energy_motor_lut.find_value_in_lookup_table,
@@ -360,7 +346,7 @@ async def _set_pol(
             if (value is not Pol.LH) and (current_pol is not Pol.LH):
                 self._polarisation_setpoint_set(Pol.LH)
                 max_lh_energy = float(
-                    self.gap_energy_motor_lu.lut.root[Pol("lh")].max_energy
+                    self.gap_energy_motor_lut.lut.root[Pol.LH].max_energy
                 )
                 lh_setpoint = (
                     max_lh_energy if target_energy > max_lh_energy else target_energy
diff --git a/src/dodal/devices/insertion_device/apple_knot_controller.py b/src/dodal/devices/insertion_device/apple_knot_controller.py
index 458e399ae4f..12c29d24eb6 100644
--- a/src/dodal/devices/insertion_device/apple_knot_controller.py
+++ b/src/dodal/devices/insertion_device/apple_knot_controller.py
@@ -168,7 +168,7 @@ async def _set_energy(self, energy: float) -> None:
         await self.check_top_bottom_phase_match()
         pol = await self._check_and_get_pol_setpoint()
         await self._combined_move(energy, pol)
-        self._energy_set(energy)
+        await self._energy.set(energy)
 
     async def check_top_bottom_phase_match(self) -> None:
         """Check that the top and bottom phase motors are in sync.
@@ -195,8 +195,8 @@ async def _combined_move(self, energy: float, pol: Pol) -> None:
             current_gap, current_phase_top, Pol.NONE
         )
         # get target apple2 value
-        target_gap = self.gap_energy_motor_converter(energy=energy, pol=pol)
-        target_phase = self.phase_energy_motor_converter(energy=energy, pol=pol)
+        target_gap = self.gap_energy_motor_converter(value=energy, pol=pol)
+        target_phase = self.phase_energy_motor_converter(value=energy, pol=pol)
         target_apple2_val = self._get_apple2_value(target_gap, target_phase, pol)
         # get path avoiding exclusion zone
         manhattan_path = self.path_finder.get_apple_knot_val_path(
diff --git a/src/dodal/devices/insertion_device/energy.py b/src/dodal/devices/insertion_device/energy.py
index b998687df6a..072ce4d8854 100644
--- a/src/dodal/devices/insertion_device/energy.py
+++ b/src/dodal/devices/insertion_device/energy.py
@@ -62,11 +62,11 @@ async def prepare(self, value: FlyMotorInfo) -> None:
         await self.set(energy=mid_energy)
         current_pol = await self.id_controller().polarisation_setpoint.get_value()
         start_position = self.id_controller().gap_energy_motor_converter(
-            energy=value.start_position,
+            value=value.start_position,
             pol=current_pol,
         )
         end_position = self.id_controller().gap_energy_motor_converter(
-            energy=value.end_position, pol=current_pol
+            value=value.end_position, pol=current_pol
         )
 
         gap_fly_motor_info = FlyMotorInfo(
@@ -122,7 +122,7 @@ def __init__(
 
     @AsyncStatus.wrap
     async def set(self, energy: float) -> None:
-        LOGGER.info(f"Moving f{self.name} energy to {energy}.")
+        LOGGER.info(f"Moving {self.name} energy to {energy}.")
         await asyncio.gather(
             self.id_energy().set(
                 energy=energy + await self.id_energy_offset.get_value()
diff --git a/src/dodal/devices/insertion_device/energy_motor_lookup.py b/src/dodal/devices/insertion_device/energy_motor_lookup.py
index 2e78f66aa77..d2fd9063a27 100644
--- a/src/dodal/devices/insertion_device/energy_motor_lookup.py
+++ b/src/dodal/devices/insertion_device/energy_motor_lookup.py
@@ -30,11 +30,11 @@ def update_lookup_table(self) -> None:
         """
         pass
 
-    def find_value_in_lookup_table(self, energy: float, pol: Pol) -> float:
+    def find_value_in_lookup_table(self, value: float, pol: Pol) -> float:
         """Convert energy and polarisation to a value from the lookup table.
 
         Args:
-            energy (float): Desired energy.
+            value (float): Desired energy.
             pol (Pol): Polarisation mode.
 
         Returns:
@@ -44,8 +44,8 @@ def find_value_in_lookup_table(self, energy: float, pol: Pol) -> float:
         # implemented it.
         if not self.lut.root:
             self.update_lookup_table()
-        poly = self.lut.get_poly(energy=energy, pol=pol)
-        return poly(energy)
+        poly = self.lut.get_poly(value=value, pol=pol)
+        return poly(value)
 
 
 class ConfigServerEnergyMotorLookup(EnergyMotorLookup):
diff --git a/src/dodal/devices/insertion_device/enum.py b/src/dodal/devices/insertion_device/enum.py
index 4bd65b93c80..56a8a9819e7 100644
--- a/src/dodal/devices/insertion_device/enum.py
+++ b/src/dodal/devices/insertion_device/enum.py
@@ -10,6 +10,8 @@ class Pol(StrictEnum):
     LA = "la"
     LH3 = "lh3"
     LV3 = "lv3"
+    PC3 = "pc3"
+    NC3 = "nc3"
 
 
 class UndulatorGateStatus(StrictEnum):
diff --git a/src/dodal/devices/insertion_device/lookup_table_models.py b/src/dodal/devices/insertion_device/lookup_table_models.py
index 71bf5e78f54..2fcbe4d58b0 100644
--- a/src/dodal/devices/insertion_device/lookup_table_models.py
+++ b/src/dodal/devices/insertion_device/lookup_table_models.py
@@ -167,19 +167,19 @@ def min_energy(self) -> float:
     def max_energy(self) -> float:
         return self.energy_entries[-1].max_energy
 
-    def get_poly(self, energy: float) -> np.poly1d:
+    def get_poly(self, value: float) -> np.poly1d:
         """Return the numpy.poly1d polynomial applicable for the given energy.
 
         Args:
-            energy (float): Energy value in the same units used to create the lookup
+            value (float): Energy value in the same units used to create the lookup
                 table.
         """
-        if not self.min_energy <= energy <= self.max_energy:
+        if not self.min_energy <= value <= self.max_energy:
             raise ValueError(
                 f"Demanding energy must lie between {self.min_energy} and {self.max_energy}!"
             )
 
-        poly_index = self.get_energy_index(energy)
+        poly_index = self.get_energy_index(value)
         if poly_index is not None:
             return self.energy_entries[poly_index].poly
         raise ValueError(
@@ -230,17 +230,17 @@ def generate(
 
     def get_poly(
         self,
-        energy: float,
+        value: float,
         pol: Pol,
     ) -> np.poly1d:
         """Return the numpy.poly1d polynomial applicable for the given energy and
         polarisation.
 
         Args:
-            energy (float): Energy value in the same units used to create the lookup table.
+            value (float): Energy value in the same units used to create the lookup table.
             pol (Pol): Polarisation mode enum.
         """
-        return self.root[pol].get_poly(energy)
+        return self.root[pol].get_poly(value)
 
 
 def convert_csv_to_lookup(
diff --git a/tests/devices/beamlines/i09_2_shared/test_i09_apple2.py b/tests/devices/beamlines/i09_2_shared/test_i09_apple2.py
index 9420444ee2c..1fc0592867d 100644
--- a/tests/devices/beamlines/i09_2_shared/test_i09_apple2.py
+++ b/tests/devices/beamlines/i09_2_shared/test_i09_apple2.py
@@ -89,7 +89,7 @@ async def mock_id_controller(
             gap_energy_motor_lut=mock_j09_gap_energy_motor_lookup,
             phase_energy_motor_lut=mock_j09_phase_energy_motor_lookup,
         )
-    mock_id_controller._energy_set(0.5)
+    set_mock_value(mock_id_controller._energy, 0.5)
     return mock_id_controller
 
 
@@ -284,8 +284,8 @@ async def test_j09_apple2_controller_set_pol(
     set_mock_value(mock_id_controller.apple2().phase().btm_inner.user_readback, 1)
     set_mock_value(mock_id_controller.apple2().phase().top_inner.user_readback, 3)
     set_mock_value(mock_id_controller.apple2().phase().btm_outer.user_readback, 4)
-    mock_id_controller.gap_energy_motor_lu.update_lookup_table()
-    mock_id_controller.phase_energy_motor_lu.update_lookup_table()
+    mock_id_controller.gap_energy_motor_lut.update_lookup_table()
+    mock_id_controller.phase_energy_motor_lut.update_lookup_table()
     await mock_id_controller.polarisation.set(pol)
     assert get_mock_put(
         mock_id_controller.apple2().phase().top_outer.user_setpoint
diff --git a/tests/devices/beamlines/i10/test_i10_apple2.py b/tests/devices/beamlines/i10/test_i10_apple2.py
index 35a2465cb87..fcdad45a14f 100644
--- a/tests/devices/beamlines/i10/test_i10_apple2.py
+++ b/tests/devices/beamlines/i10/test_i10_apple2.py
@@ -347,8 +347,8 @@ async def test_id_polarisation_set(
     expect_btm_outer: float,
     expect_gap: float,
 ):
-    set_mock_value(mock_id_controller._energy, energy)
 
+    set_mock_value(mock_id_controller._energy, energy)
     if pol == "dsf":
         with pytest.raises(ValueError):
             await mock_id_pol.set(Pol(pol))
@@ -358,29 +358,29 @@ async def test_id_polarisation_set(
         top_inner = get_mock_put(
             mock_id_controller.apple2().phase().top_inner.user_setpoint
         )
-        top_inner.assert_called_once()
+        top_inner.assert_called()
         assert float(top_inner.call_args[0][0]) == pytest.approx(expect_top_inner, 0.01)
 
         top_outer = get_mock_put(
             mock_id_controller.apple2().phase().top_outer.user_setpoint
         )
-        top_outer.assert_called_once()
+        top_outer.assert_called()
         assert float(top_outer.call_args[0][0]) == pytest.approx(expect_top_outer, 0.01)
 
         btm_inner = get_mock_put(
             mock_id_controller.apple2().phase().btm_inner.user_setpoint
         )
-        btm_inner.assert_called_once()
+        btm_inner.assert_called()
         assert float(btm_inner.call_args[0][0]) == pytest.approx(expect_btm_inner, 0.01)
 
         btm_outer = get_mock_put(
             mock_id_controller.apple2().phase().btm_outer.user_setpoint
         )
-        btm_outer.assert_called_once()
+        btm_outer.assert_called()
         assert float(btm_outer.call_args[0][0]) == pytest.approx(expect_btm_outer, 0.01)
 
         gap = get_mock_put(mock_id_controller.apple2().gap().user_setpoint)
-        gap.assert_called_once()
+        # gap.assert_called_once()
         assert float(gap.call_args[0][0]) == pytest.approx(expect_gap, 0.05)
 
 
diff --git a/tests/devices/beamlines/i17/test_i17_apple2.py b/tests/devices/beamlines/i17/test_i17_apple2.py
index cb36b0fe8ca..40473b54d5d 100644
--- a/tests/devices/beamlines/i17/test_i17_apple2.py
+++ b/tests/devices/beamlines/i17/test_i17_apple2.py
@@ -53,10 +53,10 @@ async def test_set_motors_from_energy_and_polarisation_sets_correct_values(
     mock_id_controller._check_and_get_pol_setpoint = AsyncMock(return_value=Pol.LH)
     await mock_id_controller.energy.set(100.0)
     mock_id_controller.gap_energy_motor_converter.assert_called_once_with(  # type:ignore
-        energy=100.0, pol=Pol.LH
+        value=100.0, pol=Pol.LH
     )
     mock_id_controller.phase_energy_motor_converter.assert_called_once_with(  # type:ignore
-        energy=100.0, pol=Pol.LH
+        value=100.0, pol=Pol.LH
     )
     expected_val = Apple2Val(
         gap=42.0,
diff --git a/tests/devices/insertion_device/test_apple2_controller.py b/tests/devices/insertion_device/test_apple2_controller.py
index a413b1c5afb..bca11a4b69c 100644
--- a/tests/devices/insertion_device/test_apple2_controller.py
+++ b/tests/devices/insertion_device/test_apple2_controller.py
@@ -70,6 +70,35 @@ def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
         )
 
 
+class DummyEnergyReadbackApple2Controller(
+    Apple2Controller[Apple2[UndulatorLockedPhaseAxes]]
+):
+    """Dummy class to test core logic of Apple2Controller."""
+
+    def __init__(
+        self,
+        apple2: Apple2[UndulatorLockedPhaseAxes],
+        gap_energy_motor_converter: EnergyMotorConvertor,
+        phase_energy_motor_converter: EnergyMotorConvertor,
+        gap_motor_energy_converter: EnergyMotorConvertor,
+        name: str = "",
+    ) -> None:
+        super().__init__(
+            apple2=apple2,
+            gap_energy_motor_converter=gap_energy_motor_converter,
+            phase_energy_motor_converter=phase_energy_motor_converter,
+            gap_motor_energy_converter=gap_motor_energy_converter,
+            maximum_phase_motor_position=TEST_MAXIMUM_ROW_PHASE_MOTOR_POSITION,
+            name=name,
+        )
+
+    def _get_apple2_value(self, gap: float, phase: float, pol: Pol) -> Apple2Val:
+        return Apple2Val(
+            phase=Apple2LockedPhasesVal(top_outer=phase, btm_inner=phase),
+            gap=gap,
+        )
+
+
 @pytest.fixture
 def configured_gap() -> float:
     return 42.0
@@ -80,6 +109,11 @@ def configured_phase() -> float:
     return 7.5
 
 
+@pytest.fixture
+def configured_energy() -> float:
+    return 700.5
+
+
 @pytest.fixture
 async def mock_locked_controller(
     mock_locked_apple2: Apple2[UndulatorLockedPhaseAxes],
@@ -88,8 +122,24 @@ async def mock_locked_controller(
 ) -> DummyLockedApple2Controller:
     mock_locked_controller = DummyLockedApple2Controller(
         apple2=mock_locked_apple2,
-        gap_energy_motor_converter=lambda energy, pol: configured_gap,
-        phase_energy_motor_converter=lambda energy, pol: configured_phase,
+        gap_energy_motor_converter=lambda value, pol: configured_gap,
+        phase_energy_motor_converter=lambda value, pol: configured_phase,
+    )
+    return mock_locked_controller
+
+
+@pytest.fixture
+async def mock_energy_readback_controller(
+    mock_locked_apple2: Apple2[UndulatorLockedPhaseAxes],
+    configured_gap: float,
+    configured_phase: float,
+    configured_energy: float,
+) -> DummyEnergyReadbackApple2Controller:
+    mock_locked_controller = DummyEnergyReadbackApple2Controller(
+        apple2=mock_locked_apple2,
+        gap_energy_motor_converter=lambda value, pol: configured_gap,
+        phase_energy_motor_converter=lambda value, pol: configured_phase,
+        gap_motor_energy_converter=lambda value, pol: configured_energy,
     )
     return mock_locked_controller
 
@@ -144,3 +194,10 @@ async def test_id_controller_energy_sets_correct_values(
         gap=configured_gap,
     )
     mock_locked_apple2.set.assert_awaited_once_with(id_motor_values=expected_val)
+
+
+async def test_id_controller_energy_read_correct_values_using_readback(
+    mock_energy_readback_controller: DummyEnergyReadbackApple2Controller,
+    configured_energy: float,
+):
+    assert await mock_energy_readback_controller.energy.get_value() == configured_energy
diff --git a/tests/devices/insertion_device/test_apple2_undulator.py b/tests/devices/insertion_device/test_apple2_undulator.py
index 3f502cb994b..80820441057 100644
--- a/tests/devices/insertion_device/test_apple2_undulator.py
+++ b/tests/devices/insertion_device/test_apple2_undulator.py
@@ -424,8 +424,8 @@ async def mock_locked_controller(
 ) -> DummyLockedApple2Controller:
     mock_locked_controller = DummyLockedApple2Controller(
         apple2=mock_locked_apple2,
-        gap_energy_motor_converter=lambda energy, pol: configured_gap,
-        phase_energy_motor_converter=lambda energy, pol: configured_phase,
+        gap_energy_motor_converter=lambda value, pol: configured_gap,
+        phase_energy_motor_converter=lambda value, pol: configured_phase,
     )
     return mock_locked_controller
 
diff --git a/tests/devices/insertion_device/test_apple_knot_undulator.py b/tests/devices/insertion_device/test_apple_knot_undulator.py
index 6feb92add41..007eee81ef0 100644
--- a/tests/devices/insertion_device/test_apple_knot_undulator.py
+++ b/tests/devices/insertion_device/test_apple_knot_undulator.py
@@ -1,5 +1,6 @@
 import pytest
 from ophyd_async.core import (
+    init_devices,
     set_mock_value,
 )
 
@@ -29,12 +30,13 @@ async def mock_apple_knot_i05_controller(
     mock_locked_apple2: Apple2[UndulatorLockedPhaseAxes],
     apple_knot_i05_path_finder: AppleKnotPathFinder,
 ) -> AppleKnotController[UndulatorLockedPhaseAxes]:
-    mock_apple_knot_controller = AppleKnotController[UndulatorLockedPhaseAxes](
-        apple=mock_locked_apple2,
-        gap_energy_motor_converter=energy_to_gap_converter,
-        phase_energy_motor_converter=energy_to_phase_converter,
-        path_finder=apple_knot_i05_path_finder,
-    )
+    async with init_devices(mock=True):
+        mock_apple_knot_controller = AppleKnotController[UndulatorLockedPhaseAxes](
+            apple=mock_locked_apple2,
+            gap_energy_motor_converter=energy_to_gap_converter,
+            phase_energy_motor_converter=energy_to_phase_converter,
+            path_finder=apple_knot_i05_path_finder,
+        )
     return mock_apple_knot_controller
 
 
@@ -86,7 +88,7 @@ async def test_id_set_pol(
     initial_energy: float,
     target_pol: Pol,
 ):
-    mock_apple_knot_i05_controller._energy_set(initial_energy)
+    set_mock_value(mock_apple_knot_i05_controller._energy, initial_energy)
     set_mock_value(
         mock_locked_apple2.gap().user_readback,
         energy_to_gap_converter(initial_energy, initial_pol),
@@ -120,7 +122,7 @@ async def test_id_set_pol_fails(
     initial_energy: float,
     target_pol: Pol,
 ):
-    mock_apple_knot_i05_controller._energy_set(initial_energy)
+    set_mock_value(mock_apple_knot_i05_controller._energy, initial_energy)
     set_mock_value(
         mock_locked_apple2.gap().user_readback,
         energy_to_gap_converter(initial_energy, initial_pol),
diff --git a/tests/devices/insertion_device/test_energy_motor_lookup.py b/tests/devices/insertion_device/test_energy_motor_lookup.py
index 0ef8840deeb..7f70706ca1c 100644
--- a/tests/devices/insertion_device/test_energy_motor_lookup.py
+++ b/tests/devices/insertion_device/test_energy_motor_lookup.py
@@ -27,7 +27,7 @@ def test_energy_motor_lookup_find_value_in_lookup_table(
     for i in range(len(generate_config_lut.polarisations)):
         energy = generate_config_lut.energy_coverage[i].min_energy
         value = energy_motor_lookup.find_value_in_lookup_table(
-            energy=energy,
+            value=energy,
             pol=generate_config_lut.polarisations[i],
         )
         expected_poly = generate_config_lut.energy_coverage[i].get_poly(energy)
@@ -65,7 +65,7 @@ def test_energy_motor_lookup_find_value_in_lookup_table_updates_lut_if_lut_empty
 
     energy_motor_lookup.find_value_in_lookup_table(energy, pol)
     mock_update_lut.assert_called_once()
-    mock_lut.get_poly.assert_called_once_with(energy=energy, pol=pol)
+    mock_lut.get_poly.assert_called_once_with(value=energy, pol=pol)
 
 
 @pytest.fixture
diff --git a/tests/devices/insertion_device/test_lookup_tables_models.py b/tests/devices/insertion_device/test_lookup_tables_models.py
index d1de8cd736e..0b92c151316 100644
--- a/tests/devices/insertion_device/test_lookup_tables_models.py
+++ b/tests/devices/insertion_device/test_lookup_tables_models.py
@@ -35,7 +35,7 @@ def test_lookup_table_get_poly(
     for i in range(len(generate_config_lut.polarisations)):
         min_energy = generate_config_lut.energy_coverage[i].min_energy
         poly = lut.get_poly(
-            energy=min_energy,
+            value=min_energy,
             pol=generate_config_lut.polarisations[i],
         )
         expected_poly = generate_config_lut.energy_coverage[i].get_poly(min_energy)