diff --git a/docs/cookbook/assets/star_semiautomated_plate_definition/biorad_96_wellplate_200uL_Vb.png b/docs/cookbook/assets/star_semiautomated_plate_definition/biorad_96_wellplate_200uL_Vb.png
new file mode 100644
index 00000000000..4de1fb7f449
Binary files /dev/null and b/docs/cookbook/assets/star_semiautomated_plate_definition/biorad_96_wellplate_200uL_Vb.png differ
diff --git a/docs/cookbook/star_semiautomated_plate_definition.ipynb b/docs/cookbook/star_semiautomated_plate_definition.ipynb
new file mode 100644
index 00000000000..62c0fc2debe
--- /dev/null
+++ b/docs/cookbook/star_semiautomated_plate_definition.ipynb
@@ -0,0 +1,1989 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Semi-Automated Plate Definition Generation\n",
+    "\n",
+    "- tags: #platedefinition #resourcemovement #plateadapter #hamiltonstar\n",
+    "- Last updated: 2026-01-29"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Prerequisites\n",
+    "\n",
+    "- Machines used:\n",
+    "  - Hamilton STAR\n",
+    "- Non-PLR dependencies: None \n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preview of Machine Behvaiour"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<video width=\"640\" controls autoplay loop>\n",
+    "  <source src=\"./assets/star_movement_plate_to_alpaqua_core/animation.mp4\" type=\"video/mp4\">\n",
+    "  Your browser does not support the video tag.\n",
+    "</video>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Master Information\n",
+    "\n",
+    "i.e. declare parameters that might change from run to run"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "protocol_mode = \"execution\" # \"execution\" or \"simulation\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Choose how many channels you want to be involed in probing actions (1-6 is acceptable)\n",
+    "n_channels = 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## Import Statements"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Non-PLR Dependencies\n",
+    "\n",
+    "None"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Machine & Visualizer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "       \n",
+    "import random \n",
+    "import time\n",
+    "import asyncio\n",
+    "    \n",
+    "from pylabrobot.liquid_handling import LiquidHandler\n",
+    "from pylabrobot.resources.hamilton import STARLetDeck, STARDeck\n",
+    "from pylabrobot.visualizer.visualizer import Visualizer\n",
+    "from pylabrobot.utils import chunk_list\n",
+    "\n",
+    "if protocol_mode == \"execution\":\n",
+    "\n",
+    "  from pylabrobot.liquid_handling.backends import STARBackend\n",
+    "\n",
+    "  star = STARBackend()\n",
+    "\n",
+    "elif protocol_mode == \"simulation\":\n",
+    "\n",
+    "  from pylabrobot.liquid_handling.backends.hamilton.STAR_chatterbox import STARChatterboxBackend\n",
+    "    \n",
+    "  star = STARChatterboxBackend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Required Resources"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pylabrobot.resources import (\n",
+    "    hamilton_mfx_carrier_L5_base,\n",
+    "    hamilton_mfx_plateholder_DWP_metal_tapped,\n",
+    "    hamilton_mfx_plateholder_DWP_flat,\n",
+    "    Coordinate\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Create Initial Plate Definition\n",
+    "\n",
+    "Ideally, the manufactuer publishes technical drawings which act as a starting material that requires verification in physical reality + measurements of missing parameters:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "![sd](./assets/star_semiautomated_plate_definition/biorad_96_wellplate_200uL_Vb.png)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{note}\n",
+    "PyLabRobot always uses \"front-left-bottom\" references!\n",
+    "This means that every technical drawing measurement has to be converted accordingly:\n",
+    "e.g. `dx = 14.38 (left to center_x) - 5.46 / 2 (radius of well)`.\n",
+    "\n",
+    "Furthermore, this is a special plate: its well spacing is symmetric in both the x and y dimensions!\n",
+    "This is not common, and you should always perform a multiple sanity checks to ensure you are not taking measurements from the incorrect direction: e.g. `127.76 - (14.38)*2 = 99.0` mm -> 1st column center_x and 12th column center_x are exactly 99.0 mm apart as expected based on the ANSI/SLAS 4-2004 standard and an 11 column distance -> the plate is symmetric across its welll spacing in the `x` dimension\n",
+    "```\n",
+    "\n",
+    "```{warning}\n",
+    "It is now clear whether `16.06-14.81 = 1.25` refers to the `dz` with or without the `material_z_thickness`.\n",
+    "This means without measurement we risk crashing pipette heads into the well cavity bottom - if a plate holder with a pedestal (i.e. central elevation) is used.\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pylabrobot.resources.plate import Plate\n",
+    "from pylabrobot.resources.utils import create_ordered_items_2d\n",
+    "from pylabrobot.resources.well import (\n",
+    "    CrossSectionType,\n",
+    "    Well,\n",
+    "    WellBottomType,\n",
+    ")\n",
+    "\n",
+    "def biorad_96_wellplate_200uL_Vb(name: str, with_lid: bool = False) -> Plate:\n",
+    "    \"\"\"Bio-rad cat. no.: HSP9601 (50/package), HSP9601B (8*50/package).\n",
+    "\n",
+    "    Bio-rad plate with 96-wells (V-bottoms).\n",
+    "    \"The patented rigid 2-component design is specifically engineered to\n",
+    "      withstand the stresses of thermal cycling.\" -> excellent for automation!\n",
+    "\n",
+    "    - Colour: white shell/clear well\n",
+    "    - alternative cat. no.:\n",
+    "      - red shell (HSP-9611)\n",
+    "      - yellow shell (HSP-9621)\n",
+    "      - blue shell (HSP-9631)\n",
+    "      - green shell (HSP-9641)\n",
+    "      - black shell (HSP-9661)\n",
+    "    - Material: Polypropylene\n",
+    "    - Cleanliness: \"Certified to be free of DNase, RNase, and human genomic DNA\"\n",
+    "    - Total volume/well = 200 uL\n",
+    "    - URL: https://www.bio-rad.com/en-uk/sku/HSP9601-hard-shell-96-well-pcr-plates-\n",
+    "      low-profile-thin-wall-skirted-white-clear?ID=HSP9601\n",
+    "    - technical drawing: ./assets/star_semiautomated_plate_definition/biorad_96_wellplate_200uL_Vb.png\n",
+    "    \"\"\"\n",
+    "    well_diameter = 5.46  # mm\n",
+    "    return Plate(\n",
+    "        name=name,\n",
+    "        size_x=127.76,\n",
+    "        size_y=85.48,\n",
+    "        size_z=16.06,\n",
+    "        lid=None,\n",
+    "        model=biorad_96_wellplate_200uL_Vb.__name__,\n",
+    "        ordered_items=create_ordered_items_2d(\n",
+    "            Well,\n",
+    "            num_items_x=12,\n",
+    "            num_items_y=8,\n",
+    "            dx=round(14.38-well_diameter/2, 2), # symmetric well spacing across X centerline\n",
+    "            dy=round(11.24-well_diameter/2, 2), # symmetric well spacing across Y centerline\n",
+    "            dz=1.1, # initial guess\n",
+    "            item_dx=9.0,\n",
+    "            item_dy=9.0,\n",
+    "            size_x=well_diameter,\n",
+    "            size_y=well_diameter,\n",
+    "            size_z=14.4,\n",
+    "            bottom_type=WellBottomType.V,\n",
+    "            material_z_thickness=0.65, # initial guess\n",
+    "            cross_section_type=CrossSectionType.CIRCLE,\n",
+    "            compute_volume_from_height=None,\n",
+    "            compute_height_from_volume=None,\n",
+    "        ),\n",
+    "    )\n",
+    "\n",
+    "# Modify the above if you want to change/create your own plate definition\n",
+    "# then simply change this variable which is used for the rest of this recipe\n",
+    "plate_definition_function = biorad_96_wellplate_200uL_Vb"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "11.65"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "14.38-5.46/2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Utility Functions\n",
+    "\n",
+    "Inevitably we have to create specialised solutions for specialised problems.\n",
+    "Python makes this easy by quickly generating utility functions.\n",
+    "These can be stored with you 'automated Protocol' script or, if used repeadetly be added to your internal repository, or even added to the `pylabrobot.utils` package."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_channel_wells(plate: Plate, channels_used: int):\n",
+    "    \"\"\"\n",
+    "    Generate a list of wells for multi-channel pipetting with evenly spaced rows.\n",
+    "    \n",
+    "    Returns:\n",
+    "        List of well names:\n",
+    "        e.g., generate_channel_wells(test_plate_0, 4) -> [\"A1\", \"C1\", \"E1\", \"H1\", \"A2\", \"C2\", ...])\n",
+    "    \"\"\"\n",
+    "    num_rows, num_cols = plate.num_items_y, plate.num_items_x\n",
+    "    \n",
+    "    # Generate evenly spaced row indices\n",
+    "    row_indices = [round(i * (num_rows - 1) / (channels_used - 1)) for i in range(channels_used)]\n",
+    "    \n",
+    "    # Generate well names: all columns, with selected rows per column\n",
+    "    return [f\"{chr(ord('A') + row)}{col}\" \n",
+    "            for col in range(1, num_cols + 1) \n",
+    "            for row in row_indices]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Instantiate Frontend & Connect to Machine"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-01-28 18:23:49,585 - pylabrobot.io.usb - INFO - Finding USB device...\n",
+      "2026-01-28 18:23:49,618 - pylabrobot.io.usb - INFO - Found USB device.\n",
+      "2026-01-28 18:23:49,621 - pylabrobot.io.usb - INFO - Found endpoints. \n",
+      "Write:\n",
+      "       ENDPOINT 0x2: Bulk OUT ===============================\n",
+      "       bLength          :    0x7 (7 bytes)\n",
+      "       bDescriptorType  :    0x5 Endpoint\n",
+      "       bEndpointAddress :    0x2 OUT\n",
+      "       bmAttributes     :    0x2 Bulk\n",
+      "       wMaxPacketSize   :   0x40 (64 bytes)\n",
+      "       bInterval        :    0x0 \n",
+      "Read:\n",
+      "       ENDPOINT 0x81: Bulk IN ===============================\n",
+      "       bLength          :    0x7 (7 bytes)\n",
+      "       bDescriptorType  :    0x5 Endpoint\n",
+      "       bEndpointAddress :   0x81 IN\n",
+      "       bmAttributes     :    0x2 Bulk\n",
+      "       wMaxPacketSize   :   0x40 (64 bytes)\n",
+      "       bInterval        :    0x0\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Websocket server started at http://127.0.0.1:2121\n",
+      "File server started at http://127.0.0.1:1337 . Open this URL in your browser.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'C0CDid0016er00/00'"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "deck = STARDeck()\n",
+    "lh = LiquidHandler(backend=star, deck=deck)\n",
+    "\n",
+    "await lh.setup()\n",
+    "\n",
+    "vis = Visualizer(resource=lh)\n",
+    "await vis.setup()\n",
+    "\n",
+    "await star.disable_cover_control() # 😈\n",
+    "shutdown_executed = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Configure Deck Layout"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup MFX Carrier with DWP PlateHolder that has a pedestal\n",
+    "\n",
+    "plateholder_pedestal_0 = hamilton_mfx_plateholder_DWP_metal_tapped(\n",
+    "    name=f\"plateholder_pedestal_0\"\n",
+    ")\n",
+    "\n",
+    "mfx_carrier_0 = hamilton_mfx_carrier_L5_base(\n",
+    "  name=\"mfx_carrier_0\",\n",
+    "  modules={0: plateholder_pedestal_0}\n",
+    ")\n",
+    "\n",
+    "deck.assign_child_resource(mfx_carrier_0, rails=10)\n",
+    "\n",
+    "# Setup MFX Carrier with DWP PlateHolder that has a flat bottom\n",
+    "\n",
+    "plateholder_flat_0 = hamilton_mfx_plateholder_DWP_flat(name=f\"plateholder_flat_0\")\n",
+    "\n",
+    "mfx_carrier_1 = hamilton_mfx_carrier_L5_base(\n",
+    "  name=\"mfx_carrier_1\",\n",
+    "  modules={0: plateholder_flat_0}\n",
+    ")\n",
+    "\n",
+    "deck.assign_child_resource(mfx_carrier_1, rails=17)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Opening in existing browser session.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Add plate onto PlateHolder with the pedestal\n",
+    "\n",
+    "test_plate_0 = plate_definition_function(name=\"test_plate_0\")\n",
+    "\n",
+    "mfx_carrier_0[0] = test_plate_0 "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step Calculations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['A1', 'E1', 'H1', 'A2', 'E2', 'H2', 'A3', 'E3', 'H3', 'A4']\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[289359:289359:0100/000000.565807:ERROR:content/zygote/zygote_linux.cc:673] write: Broken pipe (32)\n"
+     ]
+    }
+   ],
+   "source": [
+    "wells_to_probe = generate_channel_wells(test_plate_0, channels_used=n_channels)\n",
+    "\n",
+    "if len(wells_to_probe) > 10: # You might want to use this recipe to create a 6-wellplate definition\n",
+    "    print(wells_to_probe[:10])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## Execution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "recipe_execution_start_time = time.time()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Pickup Teaching Needles & CORE Grippers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'C0ZTid0019er00/00sx000 000 000 000 000 000 000 000sg000 000 000 000 000 000 486 509'"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "teaching_tip_rack = lh.deck.get_resource(\"teaching_tip_rack\")\n",
+    "await lh.pick_up_tips(teaching_tip_rack[\"A1:C1\"], use_channels=[0,1,2,3,4,5][:n_channels])\n",
+    "\n",
+    "await star.pick_up_core_gripper_tools(front_channel=7)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 1) Focus: Flat PlateHolder -> `dz` + `material_z_thickness`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.a.) Probe True PlateHolder Origin"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plate_holder_pedestal_child_coord = mfx_carrier_0[0].get_absolute_location()+mfx_carrier_0[0].child_location\n",
+    "\n",
+    "plate_holder_flat_child_coord = mfx_carrier_1[0].get_absolute_location()+mfx_carrier_1[0].child_location\n",
+    "\n",
+    "test_location_w_offset = plate_holder_flat_child_coord + Coordinate(x=3, y=3, z=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from tqdm.auto import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2a5e625b11ed471399ef73d2d6aedecb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0: left_pos_list=[463.1, 463.1, 463.1] | front_pos_list=[71.7, 71.9, 69.2]\n",
+      "1: left_pos_list=[463.0, 463.0, 463.0] | front_pos_list=[72.0, 72.0, 72.0]\n",
+      "2: left_pos_list=[463.2, 463.2, 463.2] | front_pos_list=[71.6, 71.7, 71.7]\n",
+      "\n",
+      "Offset of Coordinate(-00.900, 000.000, 001.400) between plate_holder child location modelled and physical reality detected!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# You might have deviations in positional accuracy across your 1000uL channels\n",
+    "# (this is what the service/Hamilton-executed calibration is mitigating)\n",
+    "# To capture this information, perform measurements with multiple channels!\n",
+    "\n",
+    "front_pos_master_list, left_pos_master_list = [], []\n",
+    "plate_holder_flat_top_surface = []\n",
+    "\n",
+    "for channel_idx in tqdm(range(n_channels)):\n",
+    "    \n",
+    "    # Prepare Z position of X-Y probing\n",
+    "    await star.move_all_channels_in_z_safety()\n",
+    "    await star.prepare_for_manual_channel_operation(channel=channel_idx)\n",
+    "    \n",
+    "    await star.move_channel_x(x=test_location_w_offset.x, channel=channel_idx)\n",
+    "    await star.move_channel_y(y= test_location_w_offset.y, channel=channel_idx)\n",
+    "    \n",
+    "    probed_z_position = await star.clld_probe_z_height_using_channel(\n",
+    "            channel_idx=channel_idx,\n",
+    "            channel_speed=6.0, start_pos_search=test_location_w_offset.z+20,\n",
+    "            detection_edge=5, post_detection_dist=2.0,\n",
+    "            move_channels_to_safe_pos_after=False\n",
+    "        ) if protocol_mode == \"execution\" else plate_holder_flat_child_coord.z\n",
+    "    plate_holder_flat_top_surface.append(probed_z_position)\n",
+    "    \n",
+    "    await star.move_channel_z(z=probed_z_position+1.0, channel=channel_idx)\n",
+    "    \n",
+    "    # X-Y Probing\n",
+    "    offset_n_replicates = 3\n",
+    "    \n",
+    "    front_pos_list = []\n",
+    "    for x in range(offset_n_replicates):\n",
+    "        probed_front_position = await star.clld_probe_y_position_using_channel(\n",
+    "            channel_idx=channel_idx,\n",
+    "            probing_direction=\"forward\",\n",
+    "            channel_speed=3,\n",
+    "            post_detection_dist=3.0,\n",
+    "            end_pos_search=test_location_w_offset.y-5\n",
+    "        ) if protocol_mode == \"execution\" else plate_holder_flat_child_coord.y\n",
+    "        front_pos_list.append(probed_front_position)\n",
+    "    \n",
+    "    left_pos_list =[]\n",
+    "    for x in range(offset_n_replicates):\n",
+    "        probed_left_position = await star.clld_probe_x_position_using_channel(\n",
+    "            channel_idx=channel_idx,\n",
+    "            probing_direction=\"left\",\n",
+    "            post_detection_dist=1.0,\n",
+    "            end_pos_search=test_location_w_offset.x-5\n",
+    "        ) if protocol_mode == \"execution\" else plate_holder_flat_child_coord.x\n",
+    "        left_pos_list.append(probed_left_position)\n",
+    "    \n",
+    "    await star.move_all_channels_in_z_safety()\n",
+    "\n",
+    "    print(f\"{channel_idx}: {left_pos_list=} | {front_pos_list=}\")\n",
+    "\n",
+    "    front_pos_master_list.extend(front_pos_list)\n",
+    "    left_pos_master_list.extend(left_pos_list)\n",
+    "    \n",
+    "true_plate_holder_flat_child_coord = Coordinate(\n",
+    "    x=round(sum(left_pos_master_list)/len(left_pos_master_list), 1),\n",
+    "    y=round(sum(front_pos_master_list)/len(front_pos_master_list), 1),\n",
+    "    z=probed_z_position,\n",
+    ")\n",
+    "\n",
+    "offset = true_plate_holder_flat_child_coord - plate_holder_flat_child_coord\n",
+    "print(\n",
+    "    f\"\\nOffset of {offset} between plate_holder child location modelled \"\n",
+    "    \"and physical reality detected!\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.b) Move Plate to Flat PlateHolder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "move_target = mfx_carrier_1[0]\n",
+    "\n",
+    "if protocol_mode == \"simulation\":\n",
+    "  time.sleep(2)\n",
+    "    \n",
+    "await lh.move_plate(\n",
+    "  plate=test_plate_0,\n",
+    "  to=move_target,\n",
+    "  use_arm=\"core\",\n",
+    "  pickup_distance_from_top=6,\n",
+    "  core_grip_strength=40,\n",
+    "  return_core_gripper=False,\n",
+    ")\n",
+    "\n",
+    "if protocol_mode == \"execution\":\n",
+    "  # \"smart\" command, will ask operator for input if it cannot find plate in\n",
+    "  # move_target location place into condition for simulation mode\n",
+    "\n",
+    "  # (1) check transfer success, (2) push plate flush\n",
+    "  await star.core_check_resource_exists_at_location_center(\n",
+    "    location=test_plate_0.get_absolute_location(),\n",
+    "    resource=test_plate_0,\n",
+    "    gripper_y_margin=9,\n",
+    "    enable_recovery=True,\n",
+    "    audio_feedback=False,\n",
+    "  )\n",
+    "\n",
+    "print(star.core_parked)\n",
+    "\n",
+    "if protocol_mode == \"simulation\":\n",
+    "  time.sleep(2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.c) Plate Height Probing\n",
+    "\n",
+    "To probe the height of the plate we do not want to probe the center because it might bend under the probing force.\n",
+    "Instead use some of the sturdy edges:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Currently modelled plate height = Plate(name='test_plate_0', size_x=127.76, size_y=85.48, size_z=16.06, location=Coordinate(004.000, 003.500, 059.805))\n",
+      "Measured plate height = 14.84\n"
+     ]
+    }
+   ],
+   "source": [
+    "channel_idx = 0\n",
+    "\n",
+    "well_A1 = test_plate_0[\"A1\"][0]\n",
+    "plate_height_test_coord = well_A1.get_absolute_location(\n",
+    "    \"left\", \"back\", \"top\"\n",
+    ") + offset + Coordinate(-2, 2, 0.0)\n",
+    "\n",
+    "await lh.backend.move_all_channels_in_z_safety()\n",
+    "\n",
+    "await lh.backend.prepare_for_manual_channel_operation(channel=channel_idx)\n",
+    "\n",
+    "await lh.backend.move_channel_x(x=plate_height_test_coord.x, channel=channel_idx)\n",
+    "await lh.backend.move_channel_y(y=plate_height_test_coord.y, channel=channel_idx)\n",
+    "\n",
+    "probed_plate_top_results = []\n",
+    "probed_plate_top = await star.ztouch_probe_z_height_using_channel(\n",
+    "    channel_idx=channel_idx,\n",
+    "    channel_speed=5.0,\n",
+    "    start_pos_search=250, # starting point above 245 safety plane\n",
+    "    move_channels_to_safe_pos_after=False  # must be False to avoid STAR C0 module\n",
+    ")\n",
+    "probed_plate_top_results.append(probed_plate_top)\n",
+    "\n",
+    "for idx in range(2):\n",
+    "    replicate_probed_plate_top = await star.ztouch_probe_z_height_using_channel(\n",
+    "        channel_idx=channel_idx,\n",
+    "        channel_speed=5.0,\n",
+    "        start_pos_search=probed_plate_top+2.0,\n",
+    "        move_channels_to_safe_pos_after=False  # must be False to avoid STAR C0 module\n",
+    "    )\n",
+    "    probed_plate_top_results.append(replicate_probed_plate_top)\n",
+    "\n",
+    "await star.move_all_channels_in_z_safety()\n",
+    "\n",
+    "\n",
+    "mean_probed_plate_top = sum(probed_plate_top_results)/len(probed_plate_top_results)\n",
+    "mean_plate_holder_flat_top_surface = sum(plate_holder_flat_top_surface)/len(plate_holder_flat_top_surface)\n",
+    "\n",
+    "measured_plate_size_z = round(mean_probed_plate_top - mean_plate_holder_flat_top_surface, 2)\n",
+    "\n",
+    "print(\n",
+    "    f\"Currently modelled plate height = {test_plate_0}\\n\"\n",
+    "    f\"Measured plate height = {measured_plate_size_z}\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[179.5, 179.4, 179.4]"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "plate_holder_flat_top_surface"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "194.27"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "probed_plate_top"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.d) Interactive X-Y Verification of Bottom-Left Well"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "channel_idx=0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_location = test_plate_0.column(0)[-1].get_absolute_location(\n",
+    "    x=\"center\",y=\"center\",z=\"top\"\n",
+    ") + offset\n",
+    "\n",
+    "await star.move_all_channels_in_z_safety()\n",
+    "\n",
+    "await star.prepare_for_manual_channel_operation(channel=channel_idx)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Position channel with teaching needle above bottom-left well"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "477.48, current_dx=11.65\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Manually modify `x_offset` if teaching needle is not in the center of the well\n",
+    "x_offset = 0.0\n",
+    "test_x = test_location.x + x_offset\n",
+    "\n",
+    "await star.move_channel_x(x=test_x, channel=channel_idx)\n",
+    "\n",
+    "current_dx = round(\n",
+    "    test_x - true_plate_holder_flat_child_coord.x - test_plate_0.children[0].get_size_x()/2,\n",
+    "    2)\n",
+    "print(f\"{test_x}, {current_dx=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Reminder from the technical drawing above: 14.38-5.46/2 = 11.65 mm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "82.74, current_dy=8.51\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Manually modify `y_offset` if teaching needle is not in the center of the well\n",
+    "y_offset = 0.0\n",
+    "test_y = test_location.y + y_offset\n",
+    "\n",
+    "await star.move_channel_y(y=test_y, channel=channel_idx)\n",
+    "\n",
+    "current_dy = round(\n",
+    "    test_y - true_plate_holder_flat_child_coord.y - test_plate_0.children[0].get_size_y()/2,\n",
+    "    2)\n",
+    "\n",
+    "print(f\"{test_y}, {current_dy=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Reminder from the technical drawing above: 11.24-5.46/2 = 8.51 mm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "196.9"
+      ]
+     },
+     "execution_count": 25,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Only to move the teaching needle into the well for visual X/Y correction\n",
+    "test_z = mean_plate_holder_flat_top_surface + measured_plate_size_z + 5.0\n",
+    "await lh.backend.move_channel_z(z=test_z, channel=channel_idx)\n",
+    "test_z"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{info}\n",
+    "At this point, take note of the `current_dx` and `current_dy`.\n",
+    "These are the actual values you will want to use and update with\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Have you updated the dx and dy? \n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'C0ZAid0214er00/00'"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "final_query = input(f\"Have you updated the dx and dy?\")\n",
+    "\n",
+    "await lh.backend.move_all_channels_in_z_safety()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.e) Store Coordinates to Probe on Flat"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "positions_to_probe_flat = [\n",
+    "    well.get_absolute_location(\"c\", \"c\", \"top\") + offset + Coordinate(x_offset, y_offset, 0.0)\n",
+    "    for well in test_plate_0.children\n",
+    "        if well.get_identifier() in wells_to_probe\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.f) Z Probing of Wells (on Flat PlateHolder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7358d32d1cb2463abb4d50305f1483ee",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Well probing took 107.66316056251526 sec\n"
+     ]
+    }
+   ],
+   "source": [
+    "if protocol_mode == \"execution\":\n",
+    "\n",
+    "    probing_start_time = time.time()\n",
+    "\n",
+    "    await lh.backend.move_all_channels_in_z_safety()\n",
+    "    use_channels = list(range(n_channels))\n",
+    "    \n",
+    "    plate_on_flat_results = []\n",
+    "    \n",
+    "    for positions in tqdm(chunk_list(positions_to_probe_flat, chunk_size=n_channels)):\n",
+    "        \n",
+    "        x_pos = [coord.x for coord in positions]\n",
+    "        y_pos = [coord.y for coord in positions]\n",
+    "        z_start_pos = mean_plate_holder_flat_top_surface + measured_plate_size_z + 5\n",
+    "        \n",
+    "        \n",
+    "        await star.move_channel_x(0, x_pos[0])\n",
+    "\n",
+    "        await star.position_channels_in_y_direction(\n",
+    "          {channel: y for channel, y in zip(use_channels, y_pos)}\n",
+    "        )\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "        # Detect well cavity bottoms\n",
+    "        start_pos_search_list = [z_start_pos for x in range(n_channels)]\n",
+    "        measured_well_bottoms_replicate_summary = []\n",
+    "        tech_n_replicates = 3 \n",
+    "        search_speeds = [10.5, 7.0, 8.5, 10.0, 8.8, 9.2, 7.8, 10.3][:n_channels]\n",
+    "\n",
+    "        for n in range(tech_n_replicates):\n",
+    "\n",
+    "            # Parallelise ztouch probing\n",
+    "            # taking care to avoid parameters which require the unparallelizable C0 command module\n",
+    "            measured_well_bottoms = await asyncio.gather(\n",
+    "                  *[\n",
+    "                      star.ztouch_probe_z_height_using_channel(\n",
+    "                          channel_idx=channel_idx,\n",
+    "                          tip_len=lh.head[channel_idx].get_tip().total_tip_length,  # must be declared to avoid STAR C0 module\n",
+    "                          channel_speed=search_speed,\n",
+    "                          start_pos_search=start_pos_z,\n",
+    "                          lowest_immers_pos=probed_z_position-2,\n",
+    "                          detection_limiter_in_PWM=0,\n",
+    "                          push_down_force_in_PWM=0,\n",
+    "                          post_detection_dist=0.0, # must be 0 to avoid STAR C0 module\n",
+    "                          move_channels_to_safe_pos_after=False  # must be False to avoid STAR C0 module\n",
+    "                    )\n",
+    "                    for channel_idx, start_pos_z, search_speed in zip(\n",
+    "                        use_channels, start_pos_search_list, search_speeds\n",
+    "                    )\n",
+    "                  ]\n",
+    "                )\n",
+    "            measured_well_bottoms_replicate_summary.append(measured_well_bottoms)\n",
+    "\n",
+    "            start_pos_search_list = [x+5 for x in measured_well_bottoms] # Accelerate\n",
+    "\n",
+    "        mean_measured_well_bottoms = [\n",
+    "            round(sum(replicates)/tech_n_replicates, 2)\n",
+    "            for replicates in list(zip(*measured_well_bottoms_replicate_summary))\n",
+    "        ]\n",
+    "        plate_on_flat_results.extend(mean_measured_well_bottoms)\n",
+    "        \n",
+    "        # SAFETY: move UP before starting next loop!\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "    await lh.backend.move_all_channels_in_z_safety()\n",
+    "    \n",
+    "    print(f\"Well probing took {time.time() - probing_start_time} sec\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(180.45, 180.86)"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "min(plate_on_flat_results), max(plate_on_flat_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.f) Move Plate back onto tapped PlateHolder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "move_target = mfx_carrier_0[0]\n",
+    "\n",
+    "await lh.move_plate(\n",
+    "  plate=test_plate_0,\n",
+    "  to=move_target,\n",
+    "  use_arm=\"core\",\n",
+    "  pickup_distance_from_top=6,\n",
+    "  core_grip_strength=40,\n",
+    "  return_core_gripper=False,\n",
+    ")\n",
+    "\n",
+    "if protocol_mode == \"execution\":\n",
+    "\n",
+    "  await star.core_check_resource_exists_at_location_center(\n",
+    "    location=test_plate_0.get_absolute_location(),\n",
+    "    resource=test_plate_0,\n",
+    "    gripper_y_margin=9,\n",
+    "    enable_recovery=True,\n",
+    "    audio_feedback=False,\n",
+    "  )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.g) Z Probing of Flat PlateHolder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "eb53c0f546a841f5b3e2e1543b35ca10",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Well probing took 83.35548710823059 sec\n"
+     ]
+    }
+   ],
+   "source": [
+    "if protocol_mode == \"execution\":\n",
+    "\n",
+    "    probing_start_time = time.time()\n",
+    "\n",
+    "    await lh.backend.move_all_channels_in_z_safety()\n",
+    "    use_channels = list(range(n_channels))\n",
+    "    \n",
+    "    plate_holder_FLAT_results = []\n",
+    "    \n",
+    "    for positions in tqdm(chunk_list(positions_to_probe_flat, chunk_size=n_channels)):\n",
+    "        \n",
+    "        x_pos = [coord.x for coord in positions]\n",
+    "        y_pos = [coord.y for coord in positions]\n",
+    "        z_start_pos =  mean_plate_holder_flat_top_surface + 5\n",
+    "        \n",
+    "        await star.move_channel_x(0, x_pos[0])\n",
+    "\n",
+    "        await star.position_channels_in_y_direction(\n",
+    "          {channel: y for channel, y in zip(use_channels, y_pos)}\n",
+    "        )\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "        # Detect well cavity bottoms\n",
+    "        start_pos_search_list = [z_start_pos for x in range(n_channels)]\n",
+    "        measured_well_bottoms_replicate_summary = []\n",
+    "        tech_n_replicates = 3 \n",
+    "        search_speeds = [10.5, 7.0, 8.5, 10.0, 8.8, 9.2, 7.8, 10.3][:n_channels]\n",
+    "\n",
+    "        for n in range(tech_n_replicates):\n",
+    "\n",
+    "            # Parallelise ztouch probing\n",
+    "            # taking care to avoid parameters which require the unparallelizable C0 command module\n",
+    "            measured_well_bottoms = await asyncio.gather(\n",
+    "                  *[\n",
+    "                      star.ztouch_probe_z_height_using_channel(\n",
+    "                          channel_idx=channel_idx,\n",
+    "                          tip_len=lh.head[channel_idx].get_tip().total_tip_length,  # must be declared to avoid STAR C0 module\n",
+    "                          channel_speed=search_speed,\n",
+    "                          start_pos_search=start_pos_z,\n",
+    "                          lowest_immers_pos=probed_z_position-2,\n",
+    "                          detection_limiter_in_PWM=0,\n",
+    "                          push_down_force_in_PWM=0,\n",
+    "                          post_detection_dist=0.0, # must be 0 to avoid STAR C0 module\n",
+    "                          move_channels_to_safe_pos_after=False  # must be False to avoid STAR C0 module\n",
+    "                    )\n",
+    "                    for channel_idx, start_pos_z, search_speed in zip(\n",
+    "                        use_channels, start_pos_search_list, search_speeds\n",
+    "                    )\n",
+    "                  ]\n",
+    "                )\n",
+    "            measured_well_bottoms_replicate_summary.append(measured_well_bottoms)\n",
+    "\n",
+    "            start_pos_search_list = [x+5 for x in measured_well_bottoms] # Accelerate\n",
+    "\n",
+    "        mean_measured_well_bottoms = [\n",
+    "            round(sum(replicates)/tech_n_replicates, 2)\n",
+    "            for replicates in list(zip(*measured_well_bottoms_replicate_summary))\n",
+    "        ]\n",
+    "        plate_holder_FLAT_results.extend(mean_measured_well_bottoms)\n",
+    "        \n",
+    "        # SAFETY: move UP before starting next loop!\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "    await lh.backend.move_all_channels_in_z_safety()\n",
+    "    \n",
+    "    print(f\"Well probing took {time.time() - probing_start_time} sec\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 1.h) Calculate `dz` + `material_z_thickness`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[1.87, 1.9, 1.79],\n",
+       " [1.99, 1.93, 1.88],\n",
+       " [2.07, 2.05, 1.96],\n",
+       " [2.18, 2.06, 2.08],\n",
+       " [2.21, 2.18, 2.08],\n",
+       " [2.33, 2.16, 2.2],\n",
+       " [2.31, 2.11, 2.23],\n",
+       " [2.21, 2.17, 2.17],\n",
+       " [2.2, 2.09, 2.19],\n",
+       " [2.09, 2.12, 2.09],\n",
+       " [1.99, 2.02, 1.91],\n",
+       " [1.88, 1.92, 1.79]]"
+      ]
+     },
+     "execution_count": 53,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dz_plus_material_z_thickness_results = [\n",
+    "    round(well_bottom-flat_surface_below_it,2)\n",
+    "    for well_bottom,flat_surface_below_it \n",
+    "    in list(zip(plate_on_flat_results, plate_holder_FLAT_results))\n",
+    "]\n",
+    "\n",
+    "chunk_list(dz_plus_material_z_thickness_results, n_channels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 2.) Focus: PlateHolder w/ Pedestal -> `material_z_thickness`"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.a) Store Coordinates to Probe on Pedestal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "positions_to_probe_pedestal = [\n",
+    "    well.get_absolute_location(\"c\", \"c\", \"top\") + Coordinate(x_offset, y_offset, 0)\n",
+    "    for well in test_plate_0.children\n",
+    "        if well.get_identifier() in wells_to_probe\n",
+    "]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.b) Z Probing of Wells (on Pedestal)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d33a4d7487194f06a258e474b5f9b894",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Well probing took 113.91992855072021 sec\n"
+     ]
+    }
+   ],
+   "source": [
+    "if protocol_mode == \"execution\":\n",
+    "\n",
+    "    probing_start_time = time.time()\n",
+    "\n",
+    "    await lh.backend.move_all_channels_in_z_safety()\n",
+    "    use_channels = list(range(n_channels))\n",
+    "    \n",
+    "    plate_on_PEDESTAL_results = []\n",
+    "    \n",
+    "    for positions in tqdm(chunk_list(positions_to_probe_pedestal, chunk_size=n_channels)):\n",
+    "        \n",
+    "        x_pos = [coord.x for coord in positions]\n",
+    "        y_pos = [coord.y for coord in positions]\n",
+    "        z_start_pos =  plate_holder_pedestal_child_coord.z + measured_plate_size_z + 5\n",
+    "        \n",
+    "        await star.move_channel_x(0, x_pos[0])\n",
+    "\n",
+    "        await star.position_channels_in_y_direction(\n",
+    "          {channel: y for channel, y in zip(use_channels, y_pos)}\n",
+    "        )\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "        # Detect well cavity bottoms\n",
+    "        start_pos_search_list = [z_start_pos for x in range(n_channels)]\n",
+    "        measured_well_bottoms_replicate_summary = []\n",
+    "        tech_n_replicates = 3 \n",
+    "        search_speeds = [10.5, 7.0, 8.5, 10.0, 8.8, 9.2, 7.8, 10.3][:n_channels]\n",
+    "\n",
+    "        for n in range(tech_n_replicates):\n",
+    "\n",
+    "            # Parallelise ztouch probing\n",
+    "            # taking care to avoid parameters which require the unparallelizable C0 command module\n",
+    "            measured_well_bottoms = await asyncio.gather(\n",
+    "                  *[\n",
+    "                      star.ztouch_probe_z_height_using_channel(\n",
+    "                          channel_idx=channel_idx,\n",
+    "                          tip_len=lh.head[channel_idx].get_tip().total_tip_length,  # must be declared to avoid STAR C0 module\n",
+    "                          channel_speed=search_speed,\n",
+    "                          start_pos_search=start_pos_z,\n",
+    "                          lowest_immers_pos=probed_z_position-2,\n",
+    "                          detection_limiter_in_PWM=0,\n",
+    "                          push_down_force_in_PWM=0,\n",
+    "                          post_detection_dist=0.0, # must be 0 to avoid STAR C0 module\n",
+    "                          move_channels_to_safe_pos_after=False  # must be False to avoid STAR C0 module\n",
+    "                    )\n",
+    "                    for channel_idx, start_pos_z, search_speed in zip(\n",
+    "                        use_channels, start_pos_search_list, search_speeds\n",
+    "                    )\n",
+    "                  ]\n",
+    "                )\n",
+    "            measured_well_bottoms_replicate_summary.append(measured_well_bottoms)\n",
+    "\n",
+    "            start_pos_search_list = [x+5 for x in measured_well_bottoms] # Accelerate\n",
+    "\n",
+    "        mean_measured_well_bottoms = [\n",
+    "            round(sum(replicates)/tech_n_replicates, 2)\n",
+    "            for replicates in list(zip(*measured_well_bottoms_replicate_summary))\n",
+    "        ]\n",
+    "        plate_on_PEDESTAL_results.extend(mean_measured_well_bottoms)\n",
+    "        \n",
+    "        # SAFETY: move UP before starting next loop!\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "    await star.move_all_channels_in_z_safety()\n",
+    "    \n",
+    "    print(f\"Well probing took {time.time() - probing_start_time} sec\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.c) Move Plate to Flat PlateHolder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n"
+     ]
+    }
+   ],
+   "source": [
+    "move_target = mfx_carrier_1[0]\n",
+    "\n",
+    "if protocol_mode == \"simulation\":\n",
+    "  time.sleep(2)\n",
+    "    \n",
+    "await lh.move_plate(\n",
+    "  plate=test_plate_0,\n",
+    "  to=move_target,\n",
+    "  use_arm=\"core\",\n",
+    "  pickup_distance_from_top=6,\n",
+    "  core_grip_strength=40,\n",
+    "  return_core_gripper=False,\n",
+    ")\n",
+    "\n",
+    "if protocol_mode == \"execution\":\n",
+    "  # \"smart\" command, will ask operator for input if it cannot find plate in\n",
+    "  # move_target location place into condition for simulation mode\n",
+    "\n",
+    "  # (1) check transfer success, (2) push plate flush\n",
+    "  await star.core_check_resource_exists_at_location_center(\n",
+    "    location=test_plate_0.get_absolute_location(),\n",
+    "    resource=test_plate_0,\n",
+    "    gripper_y_margin=9,\n",
+    "    enable_recovery=True,\n",
+    "    audio_feedback=False,\n",
+    "  )\n",
+    "\n",
+    "print(star.core_parked)\n",
+    "\n",
+    "if protocol_mode == \"simulation\":\n",
+    "  time.sleep(2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.d) Z Probing of PlateHolder w/ Pedestal"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d59f642ca7d545dd8a07ec3d1fdfa77c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Well probing took 83.25026893615723 sec\n"
+     ]
+    }
+   ],
+   "source": [
+    "if protocol_mode == \"execution\":\n",
+    "\n",
+    "    probing_start_time = time.time()\n",
+    "\n",
+    "    await lh.backend.move_all_channels_in_z_safety()\n",
+    "    use_channels = list(range(n_channels))\n",
+    "    \n",
+    "    plate_holder_PEDESTAL_results = []\n",
+    "    \n",
+    "    for positions in tqdm(chunk_list(positions_to_probe_pedestal, chunk_size=n_channels)):\n",
+    "        \n",
+    "        x_pos = [coord.x for coord in positions]\n",
+    "        y_pos = [coord.y for coord in positions]\n",
+    "        z_start_pos =  plate_holder_pedestal_child_coord.z + 5\n",
+    "        \n",
+    "        await star.move_channel_x(0, x_pos[0])\n",
+    "\n",
+    "        await star.position_channels_in_y_direction(\n",
+    "          {channel: y for channel, y in zip(use_channels, y_pos)}\n",
+    "        )\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "        # Detect well cavity bottoms\n",
+    "        start_pos_search_list = [z_start_pos for x in range(n_channels)]\n",
+    "        measured_well_bottoms_replicate_summary = []\n",
+    "        tech_n_replicates = 3 \n",
+    "        search_speeds = [10.5, 7.0, 8.5, 10.0, 8.8, 9.2, 7.8, 10.3][:n_channels]\n",
+    "\n",
+    "        for n in range(tech_n_replicates):\n",
+    "\n",
+    "            # Parallelise ztouch probing\n",
+    "            # taking care to avoid parameters which require the unparallelizable C0 command module\n",
+    "            measured_well_bottoms = await asyncio.gather(\n",
+    "                  *[\n",
+    "                      star.ztouch_probe_z_height_using_channel(\n",
+    "                          channel_idx=channel_idx,\n",
+    "                          tip_len=lh.head[channel_idx].get_tip().total_tip_length,  # must be declared to avoid STAR C0 module\n",
+    "                          channel_speed=search_speed,\n",
+    "                          start_pos_search=start_pos_z,\n",
+    "                          lowest_immers_pos=probed_z_position-2,\n",
+    "                          detection_limiter_in_PWM=0,\n",
+    "                          push_down_force_in_PWM=0,\n",
+    "                          post_detection_dist=0.0, # must be 0 to avoid STAR C0 module\n",
+    "                          move_channels_to_safe_pos_after=False  # must be False to avoid STAR C0 module\n",
+    "                    )\n",
+    "                    for channel_idx, start_pos_z, search_speed in zip(\n",
+    "                        use_channels, start_pos_search_list, search_speeds\n",
+    "                    )\n",
+    "                  ]\n",
+    "                )\n",
+    "            measured_well_bottoms_replicate_summary.append(measured_well_bottoms)\n",
+    "\n",
+    "            start_pos_search_list = [x+5 for x in measured_well_bottoms] # Accelerate\n",
+    "\n",
+    "        mean_measured_well_bottoms = [\n",
+    "            round(sum(replicates)/tech_n_replicates, 2)\n",
+    "            for replicates in list(zip(*measured_well_bottoms_replicate_summary))\n",
+    "        ]\n",
+    "        plate_holder_PEDESTAL_results.extend(mean_measured_well_bottoms)\n",
+    "        \n",
+    "        # SAFETY: move UP before starting next loop!\n",
+    "        await star.position_channels_in_z_direction(\n",
+    "          {channel: z_start_pos for channel in use_channels}\n",
+    "        )\n",
+    "\n",
+    "    await star.move_all_channels_in_z_safety()\n",
+    "    \n",
+    "    print(f\"Well probing took {time.time() - probing_start_time} sec\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### 2.e) Calculate `material_z_thickness`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[0.65, 0.71, 0.68],\n",
+       " [0.68, 0.74, 0.7],\n",
+       " [0.76, 0.8, 0.75],\n",
+       " [0.82, 0.87, 0.83],\n",
+       " [0.87, 0.94, 0.83],\n",
+       " [0.89, 0.89, 0.87],\n",
+       " [0.88, 0.88, 0.89],\n",
+       " [0.84, 0.84, 0.9],\n",
+       " [0.82, 0.91, 0.88],\n",
+       " [0.79, 0.85, 0.78],\n",
+       " [0.71, 0.83, 0.71],\n",
+       " [0.65, 0.78, 0.68]]"
+      ]
+     },
+     "execution_count": 49,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "material_z_thickness_results = [\n",
+    "    round(well_bottom-flat_surface_below_it,2)\n",
+    "    for well_bottom,flat_surface_below_it \n",
+    "    in list(zip(plate_on_PEDESTAL_results, plate_holder_PEDESTAL_results))\n",
+    "]\n",
+    "\n",
+    "chunk_list(material_z_thickness_results, n_channels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### 3.) Update Summary for Plate Definition"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 59,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[[1.22, 1.19, 1.11],\n",
+       " [1.31, 1.19, 1.18],\n",
+       " [1.31, 1.25, 1.21],\n",
+       " [1.36, 1.19, 1.25],\n",
+       " [1.34, 1.24, 1.25],\n",
+       " [1.44, 1.27, 1.33],\n",
+       " [1.43, 1.23, 1.34],\n",
+       " [1.37, 1.33, 1.27],\n",
+       " [1.38, 1.18, 1.31],\n",
+       " [1.3, 1.27, 1.31],\n",
+       " [1.28, 1.19, 1.2],\n",
+       " [1.23, 1.14, 1.11]]"
+      ]
+     },
+     "execution_count": 59,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dz_results = [\n",
+    "    round(combined-m_thickness,2)\n",
+    "    for combined, m_thickness\n",
+    "    in list(zip(dz_plus_material_z_thickness_results, material_z_thickness_results))\n",
+    "]\n",
+    "\n",
+    "chunk_list(dz_results, n_channels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `dz` & `material_z_thickness`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "mean_dz=1.26 | mean_material_z_thickness=0.8\n"
+     ]
+    }
+   ],
+   "source": [
+    "mean_material_z_thickness = round(\n",
+    "    sum(material_z_thickness_results)/len(material_z_thickness_results),\n",
+    "    2\n",
+    ")\n",
+    "mean_dz = round(\n",
+    "    sum(dz_results)/len(dz_results),\n",
+    "    2\n",
+    ")\n",
+    "\n",
+    "print(f\"{mean_dz=} | {mean_material_z_thickness=}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Reminder from the technical drawing above: 16.06 - 14.82 = 1.24 mm\n",
+    "\n",
+    "This shows that the `dz` value was reported in the technical drawing but the `material_z_thickness` was omitted!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### `dx` & `dy`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Updates to dx = 0.0, and dy = 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"Required updates to dx = {x_offset}, and dy = {y_offset}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Plate size_z / height"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 66,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(14.84, 16.06)"
+      ]
+     },
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "measured_plate_size_z, test_plate_0.get_size_z()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "If there is a deviation in the plate height, check that whether the wells protrude above the plate.\n",
+    "This is a common plate feature that facilitates heat sealing.\n",
+    "\n",
+    "Technical drawings often only report the combined plate and well size_z.\n",
+    "\n",
+    "```{note}\n",
+    "For PyLabRobot, you have to define `plate.size_z` as *just* the pure plate height, i.e. without the protruding wells.\n",
+    "This ensures `pickup_distance_from_top=6` will correctly pick up a plate 6 mm from its top!\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Return Tools"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 69,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "await lh.backend.return_core_gripper_tools()\n",
+    "\n",
+    "channel_tip_occupancy = await lh.backend.request_tip_presence()\n",
+    "if any(channel_tip_occupancy):\n",
+    "    await lh.return_tips()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Time Report"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Execution of this recipe took 19.67 min\n"
+     ]
+    }
+   ],
+   "source": [
+    "recipe_execution_end_time = time.time()-recipe_execution_start_time\n",
+    "\n",
+    "print(f\"Execution of this recipe took {round(recipe_execution_end_time/60, 2)} min\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Shutdown"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2026-01-28 19:00:21,016 - pylabrobot.io.usb - WARNING - Closing connection to USB device.\n"
+     ]
+    }
+   ],
+   "source": [
+    "if protocol_mode == 'execution':\n",
+    "    await star.move_all_channels_in_z_safety()\n",
+    "\n",
+    "    if star.core96_head_installed:\n",
+    "        await star.head96_move_to_z_safety()\n",
+    "\n",
+    "    if star.iswap_installed:\n",
+    "        await star.park_iswap()\n",
+    "    \n",
+    "    if not star.core_parked: # return grippers\n",
+    "        await star.return_core_gripper_tools()\n",
+    "        await star.move_all_channels_in_z_safety()\n",
+    "\n",
+    "    # discard tips if any are present\n",
+    "    has_tip_check = [lh.head[idx].has_tip for idx in range(8)]\n",
+    "    if any(has_tip_check):\n",
+    "        await lh.discard_tips()\n",
+    "    else:\n",
+    "        await star.move_channel_x(x=400, channel=0)\n",
+    "    await star.spread_pip_channels()\n",
+    "\n",
+    "await lh.stop()\n",
+    "\n",
+    "shutdown_executed = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## (Recovery Options)\n",
+    "\n",
+    "Useful if you want to quickly remove the teaching needles and/or grippers."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Channels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "##### Return Tips"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "if not shutdown_executed:\n",
+    "    channel_tip_occupancy = await lh.backend.request_tip_presence()\n",
+    "    if any(channel_tip_occupancy):\n",
+    "        await lh.return_tips()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "### Return CORE Grippers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 72,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if not shutdown_executed:\n",
+    "    await lh.backend.return_core_gripper_tools()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}