mx-bluesky 0.0.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

mx_bluesky/{I24 → beamlines/i24}/serial/fixed_target/i24ssx_Chip_Manager_py3v1.py

@@ -2,9 +2,7 @@
 Chip manager for fixed target
 This version changed to python3 March2020 by RLO
 """
-from __future__ import annotations
 
-import argparse
 import json
 import logging
 import re
@@ -12,31 +10,59 @@ import shutil
 import sys
 import time
 from pathlib import Path
+from pprint import pformat
 from time import sleep
 
+import bluesky.plan_stubs as bps
 import numpy as np
-
-from mx_bluesky.I24.serial import log
-from mx_bluesky.I24.serial.fixed_target import i24ssx_Chip_Mapping_py3v1 as mapping
-from mx_bluesky.I24.serial.fixed_target import i24ssx_Chip_StartUp_py3v1 as startup
-from mx_bluesky.I24.serial.fixed_target.ft_utils import ChipType, MappingType
-from mx_bluesky.I24.serial.parameters.constants import (
+from blueapi.core import MsgGenerator
+from dodal.beamlines import i24
+from dodal.common import inject
+from dodal.devices.i24.beamstop import Beamstop, BeamstopPositions
+from dodal.devices.i24.dual_backlight import BacklightPositions, DualBacklight
+from dodal.devices.i24.i24_detector_motion import DetectorMotion
+from dodal.devices.i24.pmac import PMAC, EncReset, LaserSettings
+
+from mx_bluesky.beamlines.i24.serial import log
+from mx_bluesky.beamlines.i24.serial.fixed_target import (
+    i24ssx_Chip_Mapping_py3v1 as mapping,
+)
+from mx_bluesky.beamlines.i24.serial.fixed_target import (
+    i24ssx_Chip_StartUp_py3v1 as startup,
+)
+from mx_bluesky.beamlines.i24.serial.fixed_target.ft_utils import (
+    ChipType,
+    Fiducials,
+    MappingType,
+)
+from mx_bluesky.beamlines.i24.serial.parameters import get_chip_format
+from mx_bluesky.beamlines.i24.serial.parameters.constants import (
     CS_FILES_PATH,
     FULLMAP_PATH,
     LITEMAP_PATH,
+    PARAM_FILE_NAME,
     PARAM_FILE_PATH_FT,
     PVAR_FILE_PATH,
 )
-from mx_bluesky.I24.serial.setup_beamline import caget, caput, pv
-from mx_bluesky.I24.serial.setup_beamline.setup_detector import get_detector_type
+from mx_bluesky.beamlines.i24.serial.setup_beamline import Pilatus, caget, caput, pv
+from mx_bluesky.beamlines.i24.serial.setup_beamline.setup_detector import (
+    get_detector_type,
+)
 
 logger = logging.getLogger("I24ssx.chip_manager")
 
-
-def _coerce_to_path(path: Path | str) -> Path:
-    if not isinstance(path, Path):
-        return Path(path)
-    return path
+# An approximation of the chip size for the move during fiducials alignment.
+CHIP_MOVES = {
+    ChipType.Oxford: 25.40,
+    ChipType.OxfordInner: 24.60,
+    ChipType.Custom: 25.40,
+    ChipType.Minichip: 25.40,
+}
+CHIPTYPE_PV = pv.me14e_gp1
+MAPTYPE_PV = pv.me14e_gp2
+NUM_EXPOSURES_PV = pv.me14e_gp3
+PUMP_REPEAT_PV = pv.me14e_gp4
+MAP_FILEPATH_PV = pv.me14e_gp5
 
 
 def setup_logging():
@@ -46,47 +72,40 @@ def setup_logging():
 
 
 @log.log_on_entry
-def initialise():
-    # commented out filter lines 230719 as this stage not connected
-    logger.info("Setting VMAX VELO ACCL HHL LLM pvs")
-
-    caput(pv.me14e_stage_x + ".VMAX", 20)
-    caput(pv.me14e_stage_y + ".VMAX", 20)
-    caput(pv.me14e_stage_z + ".VMAX", 20)
-    # caput(pv.me14e_filter  + '.VMAX', 20)
-    caput(pv.me14e_stage_x + ".VELO", 20)
-    caput(pv.me14e_stage_y + ".VELO", 20)
-    caput(pv.me14e_stage_z + ".VELO", 20)
-    # caput(pv.me14e_filter  + '.VELO', 20)
-    caput(pv.me14e_stage_x + ".ACCL", 0.01)
-    caput(pv.me14e_stage_y + ".ACCL", 0.01)
-    caput(pv.me14e_stage_z + ".ACCL", 0.01)
-    # caput(pv.me14e_filter  + '.ACCL', 0.01)
-    caput(pv.me14e_stage_x + ".HLM", 30)
-    caput(pv.me14e_stage_x + ".LLM", -29)
-    caput(pv.me14e_stage_y + ".HLM", 30)
-    caput(pv.me14e_stage_y + ".LLM", -30)
-    # caput(pv.me14e_stage_x + '.LLM', -30)
-    caput(pv.me14e_stage_z + ".HLM", 5.1)
-    caput(pv.me14e_stage_z + ".LLM", -4.1)
-    # caput(pv.me14e_filter  + '.HLM', 45.0)
-    # caput(pv.me14e_filter  + '.LLM', -45.0)
-    caput(pv.me14e_gp1, 1)
-    caput(pv.me14e_gp2, 0)
-    caput(pv.me14e_gp3, 1)
-    caput(pv.me14e_gp4, 0)
+def initialise_stages(
+    pmac: PMAC = inject("pmac"),
+) -> MsgGenerator:
+    """Initialise the portable stages PVs, usually used only once right after setting \
+        up the stages either after use at different facility.
+    """
+    setup_logging()
+    group = "initialise_stages"
+    logger.info("Setting velocity, acceleration and limits for stages")
+
+    yield from bps.abs_set(pmac.x.velocity, 20, group=group)
+    yield from bps.abs_set(pmac.y.velocity, 20, group=group)
+    yield from bps.abs_set(pmac.z.velocity, 20, group=group)
+    yield from bps.abs_set(pmac.x.acceleration_time, 0.01, group=group)
+    yield from bps.abs_set(pmac.y.acceleration_time, 0.01, group=group)
+    yield from bps.abs_set(pmac.z.acceleration_time, 0.01, group=group)
+    yield from bps.abs_set(pmac.x.high_limit_travel, 30, group=group)
+    yield from bps.abs_set(pmac.x.low_limit_travel, -29, group=group)
+    yield from bps.abs_set(pmac.y.high_limit_travel, 30, group=group)
+    yield from bps.abs_set(pmac.y.low_limit_travel, -30, group=group)
+    yield from bps.abs_set(pmac.z.high_limit_travel, 5.1, group=group)
+    yield from bps.abs_set(pmac.z.low_limit_travel, -4.1, group=group)
+    caput(CHIPTYPE_PV, 1)  # chip type
+    caput(MAPTYPE_PV, 0)  # map type
+    caput(NUM_EXPOSURES_PV, 1)  # num exposures
+    caput(PUMP_REPEAT_PV, 0)  # pump repeat
     caput(pv.me14e_filepath, "test")
     caput(pv.me14e_chip_name, "albion")
     caput(pv.me14e_dcdetdist, 1480)
     caput(pv.me14e_exptime, 0.01)
-    caput(pv.me14e_pmac_str, "m508=100 m509=150")
-    caput(pv.me14e_pmac_str, "m608=100 m609=150")
-    caput(pv.me14e_pmac_str, "m708=100 m709=150")
-    caput(pv.me14e_pmac_str, "m808=100 m809=150")
-
-    # Define detector in use
-    logger.debug("Define detector in use.")
-    det_type = get_detector_type()
+    yield from bps.abs_set(pmac.enc_reset, EncReset.ENC5, group=group)
+    yield from bps.abs_set(pmac.enc_reset, EncReset.ENC6, group=group)
+    yield from bps.abs_set(pmac.enc_reset, EncReset.ENC7, group=group)
+    yield from bps.abs_set(pmac.enc_reset, EncReset.ENC8, group=group)
 
     caput(pv.pilat_cbftemplate, 0)
 
@@ -98,95 +117,76 @@ def initialise():
         sys.stdout.write(".")
         sys.stdout.flush()
 
-    caput(pv.me14e_gp100, "press set params to read visit")
-    caput(pv.me14e_gp101, det_type.name)
-
-    logger.info("Initialisation Complete")
+    logger.info("Initialisation of the stages complete")
+    yield from bps.wait(group=group)
 
 
 @log.log_on_entry
-def write_parameter_file(param_path: Path | str = PARAM_FILE_PATH_FT):
-    param_path = _coerce_to_path(param_path)
+def write_parameter_file(
+    detector_stage: DetectorMotion,
+) -> MsgGenerator:
+    param_path: Path = PARAM_FILE_PATH_FT
+    # Create directory if it doesn't yet exist.
     param_path.mkdir(parents=True, exist_ok=True)
 
-    param_fid = "parameters.txt"
-    logger.info("Writing Parameter File: %s" % (param_path / param_fid).as_posix())
-
-    visit = caget(pv.me14e_gp100)
+    logger.info(f"Writing Parameter File: {(param_path / PARAM_FILE_NAME).as_posix()}")
 
     filename = caget(pv.me14e_chip_name)
-
-    exptime = caget(pv.me14e_exptime)
-    dcdetdist = caget(pv.me14e_dcdetdist)
-    protein_name = caget(pv.me14e_filepath)
-    pump_repeat = caget(pv.me14e_gp4)
-    pumpexptime = caget(pv.me14e_gp103)
-    pumpdelay = caget(pv.me14e_gp110)
-    prepumpexptime = caget(pv.me14e_gp109)
-    n_exposures = caget(pv.me14e_gp3)
-    map_type = caget(pv.me14e_gp2)
-    chip_type = caget(pv.me14e_gp1)
-    det_type = get_detector_type()
-
-    checkerpattern = bool(caget(pv.me14e_gp111))
+    det_type = yield from get_detector_type(detector_stage)
+    chip_params = get_chip_format(ChipType(int(caget(CHIPTYPE_PV))))
+    map_type = int(caget(MAPTYPE_PV))
+    pump_repeat = int(caget(PUMP_REPEAT_PV))
 
     # If file name ends in a digit this causes processing/pilatus pain.
     # Append an underscore
-    if det_type == "pilatus":
+    if isinstance(det_type, Pilatus):
         caput(pv.pilat_cbftemplate, 0)
         m = re.search(r"\d+$", filename)
         if m is not None:
             # Note for future reference. Appending underscore causes more hassle and
             # high probability of users accidentally overwriting data. Use a dash
             filename = filename + "-"
-            logger.info(
-                "Requested filename ends in a number. Appended dash: %s" % filename
+            logger.debug(
+                f"Requested filename ends in a number. Appended dash: {filename}"
             )
 
-    # historical - use chip_name instead of filename
-    chip_name = filename
-
-    with open(param_path / param_fid, "w") as f:
-        f.write("visit \t\t%s\n" % visit)
-        f.write("chip_name \t%s\n" % chip_name)
-        f.write("protein_name \t%s\n" % protein_name)
-        f.write("n_exposures \t%s\n" % n_exposures)
-        f.write("chip_type \t%s\n" % chip_type)
-        f.write("map_type \t%s\n" % map_type)
-        f.write("pump_repeat \t%s\n" % pump_repeat)
-        f.write("pumpexptime \t%s\n" % pumpexptime)
-        f.write("pumpdelay \t%s\n" % pumpdelay)
-        f.write("prepumpexptime \t%s\n" % prepumpexptime)
-        f.write("exptime \t%s\n" % exptime)
-        f.write("dcdetdist \t%s\n" % dcdetdist)
-        f.write("det_type \t%s\n" % str(det_type))
-        f.write("checkerpattern \t%s\n" % str(checkerpattern))
-
-    logger.info("Information written to file")
-    logger.info(f"visit: {visit}")
-    logger.info(f"filename: {chip_name}")
-    logger.info(f"protein_name: {protein_name}")
-    logger.info(f"n_exposures: {n_exposures}")
-    logger.info(f"chip_type: {chip_type}")
-    logger.info(f"map_type: {map_type}")
-    logger.info(f"pump_repeat: {pump_repeat}")
-    logger.info(f"pumpexptime: {pumpexptime}")
-    logger.info(f"pumpdelay: {pumpdelay}")
-    logger.info(f"prepumpexptime: {prepumpexptime}")
-    logger.info(f"detector type: {str(det_type)}")
-    logger.info(f"checker pattern: {checkerpattern}")
+    params_dict = {
+        "visit": log._read_visit_directory_from_file().as_posix(),  # noqa
+        "directory": caget(pv.me14e_filepath),
+        "filename": filename,
+        "exposure_time_s": caget(pv.me14e_exptime),
+        "detector_distance_mm": caget(pv.me14e_dcdetdist),
+        "detector_name": str(det_type),
+        "num_exposures": int(caget(NUM_EXPOSURES_PV)),
+        "chip": chip_params.dict(),
+        "map_type": map_type,
+        "pump_repeat": pump_repeat,
+        "checker_pattern": bool(caget(pv.me14e_gp111)),
+        "laser_dwell_s": float(caget(pv.me14e_gp103)) if pump_repeat != 0 else None,
+        "laser_delay_s": float(caget(pv.me14e_gp110)) if pump_repeat != 0 else None,
+        "pre_pump_exposure_s": float(caget(pv.me14e_gp109))
+        if pump_repeat != 0
+        else None,
+    }
+
+    with open(param_path / PARAM_FILE_NAME, "w") as f:
+        json.dump(params_dict, f, indent=4)
+
+    logger.info("Information written to file \n")
+    logger.info(pformat(params_dict))
+
     if map_type == MappingType.Full:
         # This step creates some header files (.addr, .spec), containing the parameters,
         # that are only needed when full mapping is in use.
-        logger.debug("Running start up now.")
+        logger.info("Full mapping in use. Running start up now.")
         startup.run()
+    yield from bps.null()
 
 
-def scrape_pvar_file(fid: str, pvar_dir: Path | str = PVAR_FILE_PATH):
+def scrape_pvar_file(fid: str, pvar_dir: Path = PVAR_FILE_PATH):
     block_start_list = []
-    pvar_dir = _coerce_to_path(pvar_dir)
 
-    with open(pvar_dir / fid, "r") as f:
+    with open(pvar_dir / fid) as f:
         lines = f.readlines()
     for line in lines:
         line = line.rstrip()
@@ -210,40 +210,40 @@ def scrape_pvar_file(fid: str, pvar_dir: Path | str = PVAR_FILE_PATH):
 @log.log_on_entry
 def define_current_chip(
     chipid: str = "oxford",
-    param_path: Path | str = PVAR_FILE_PATH,
-):
+    pmac: PMAC = inject("pmac"),
+) -> MsgGenerator:
+    setup_logging()
     logger.debug("Run load stock map for just the first block")
-    load_stock_map("Just The First Block")
+    yield from load_stock_map("Just The First Block")
     """
     Not sure what this is for:
     print 'Setting Mapping Type to Lite'
     caput(pv.me14e_gp2, 1)
     """
-    chip_type = int(caget(pv.me14e_gp1))
-    logger.info("Chip type:%s Chipid:%s" % (chip_type, chipid))
+    chip_type = int(caget(CHIPTYPE_PV))
+    logger.info(f"Chip type:{chip_type} Chipid:{chipid}")
     if chipid == "oxford":
-        caput(pv.me14e_gp1, 1)
-
-    param_path = _coerce_to_path(param_path)
+        caput(CHIPTYPE_PV, 0)
 
-    with open(param_path / f"{chipid}.pvar", "r") as f:
-        logger.info("Opening %s.pvar" % chipid)
+    with open(PVAR_FILE_PATH / f"{chipid}.pvar") as f:
+        logger.info(f"Opening {chipid}.pvar")
         for line in f.readlines():
             if line.startswith("#"):
                 continue
             line_from_file = line.rstrip("\n")
-            logger.info("%s" % line_from_file)
-            caput(pv.me14e_pmac_str, line_from_file)
+            logger.info(f"{line_from_file}")
+            yield from bps.abs_set(pmac.pmac_string, line_from_file)
 
 
 @log.log_on_entry
-def save_screen_map(litemap_path: Path | str = LITEMAP_PATH):
-    litemap_path = _coerce_to_path(litemap_path)
+def save_screen_map() -> MsgGenerator:
+    setup_logging()
+    litemap_path: Path = LITEMAP_PATH
     litemap_path.mkdir(parents=True, exist_ok=True)
 
-    logger.info("Saving %s currentchip.map" % litemap_path.as_posix())
+    logger.info(f"Saving {litemap_path.as_posix()} currentchip.map")
     with open(litemap_path / "currentchip.map", "w") as f:
-        logger.info("Printing only blocks with block_val == 1")
+        logger.debug("Printing only blocks with block_val == 1")
         for x in range(1, 82):
             block_str = "ME14E-MO-IOC-01:GP%i" % (x + 10)
             block_val = int(caget(block_str))
@@ -251,23 +251,23 @@ def save_screen_map(litemap_path: Path | str = LITEMAP_PATH):
                 logger.info("%s %d" % (block_str, block_val))
             line = "%02dstatus    P3%02d1 \t%s\n" % (x, x, block_val)
             f.write(line)
-    return 0
+    yield from bps.null()
 
 
 @log.log_on_entry
-def upload_parameters(
-    chipid: str = "oxford",
-    litemap_path: Path | str = LITEMAP_PATH,
-):
-    logger.info("Uploading Parameters to the GeoBrick")
-    if chipid == "oxford":
-        caput(pv.me14e_gp1, 0)
-        width = 8
-    litemap_path = _coerce_to_path(litemap_path)
+def upload_parameters(pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    setup_logging()
+    logger.info("Uploading Parameters for Oxford Chip to the GeoBrick")
+    caput(CHIPTYPE_PV, 0)
+    width = 8
 
-    with open(litemap_path / "currentchip.map", "r") as f:
-        logger.info("Chipid %s" % chipid)
-        logger.info("width %d" % width)
+    map_file: Path = LITEMAP_PATH / "currentchip.map"
+    if not map_file.exists():
+        raise FileNotFoundError(f"The file {map_file} has not yet been created")
+
+    with open(map_file) as f:
+        logger.info(f"Chipid {ChipType.Oxford}")
+        logger.info(f"width {width}")
         x = 1
         for line in f.readlines()[: width**2]:
             cols = line.split()
@@ -285,33 +285,42 @@ def upload_parameters(
                 x = 1
             else:
                 x += 1
-            caput(pv.me14e_pmac_str, s)
+            yield from bps.abs_set(pmac.pmac_string, s, wait=True)
             sleep(0.02)
 
     logger.warning("Automatic Setting Mapping Type to Lite has been disabled")
     logger.debug("Upload parameters done.")
+    yield from bps.null()
 
 
 @log.log_on_entry
-def upload_full(fullmap_path: Path | str = FULLMAP_PATH):
-    fullmap_path = _coerce_to_path(fullmap_path)
+def upload_full(pmac: PMAC | None = None) -> MsgGenerator:
+    setup_logging()
+    if not pmac:
+        pmac = i24.pmac()
 
-    with open(fullmap_path / "currentchip.full", "r") as fh:
+    map_file: Path = FULLMAP_PATH / "currentchip.full"
+    if not map_file.exists():
+        raise FileNotFoundError(f"The file {map_file} has not yet been created")
+    with open(map_file) as fh:
         f = fh.readlines()
 
-    for i in range(len(f) // 2):
+    for _i in range(len(f) // 2):
         pmac_list = []
-        for j in range(2):
+        for _j in range(2):
             pmac_list.append(f.pop(0).rstrip("\n"))
         writeline = " ".join(pmac_list)
-        logger.info("%s" % writeline)
-        caput(pv.me14e_pmac_str, writeline)
-        sleep(0.02)
+        logger.info(f"{writeline}")
+        yield from bps.abs_set(pmac.pmac_string, writeline, wait=True)
+        yield from bps.sleep(0.02)
     logger.debug("Upload fullmap done")
+    yield from bps.null()
 
 
 @log.log_on_entry
-def load_stock_map(map_choice: str = "clear"):
+def load_stock_map(map_choice: str = "clear") -> MsgGenerator:
+    # TODO See https://github.com/DiamondLightSource/mx_bluesky/issues/122
+    setup_logging()
     logger.info("Adjusting Lite Map EDM Screen")
     logger.debug("Please wait, adjusting lite map")
     #
@@ -406,7 +415,7 @@ def load_stock_map(map_choice: str = "clear"):
         28,
         27,
         10,
-    ] + x77
+    ] + x77  # noqa
     x44 = [22, 21, 20, 19, 30, 35, 46, 45, 44, 43, 38, 27, 28, 29, 36, 37]
     x49 = [x + 1 for x in range(49)]
     x66 = [
@@ -496,24 +505,26 @@ def load_stock_map(map_choice: str = "clear"):
     map_dict["half1"] = half1
     map_dict["half2"] = half2
 
-    logger.info("Clearing GP 10-74")
+    logger.info("Clearing GP 10-74")  # Actually 11-44
     for i in range(1, 65):
         pvar = "ME14E-MO-IOC-01:GP" + str(i + 10)
         caput(pvar, 0)
         sys.stdout.write(".")
         sys.stdout.flush()
     logger.info("Map cleared")
-    logger.info("Loading Map Choice %s" % map_choice)
+    logger.info(f"Loading Map Choice {map_choice}")
     for i in map_dict[map_choice]:
         pvar = "ME14E-MO-IOC-01:GP" + str(i + 10)
         caput(pvar, 1)
     logger.debug("Load stock map done.")
+    yield from bps.null()
 
 
 @log.log_on_entry
-def load_lite_map(litemap_path: Path | str = LITEMAP_PATH):
+def load_lite_map() -> MsgGenerator:
+    setup_logging()
     logger.debug("Run load stock map with 'clear' setting.")
-    load_stock_map("clear")
+    yield from load_stock_map("clear")
     # fmt: off
     # Oxford_block_dict is wrong (columns and rows need to flip) added in script below to generate it automatically however kept this for backwards compatiability/reference
     oxford_block_dict = {   # noqa: F841
@@ -527,7 +538,7 @@ def load_lite_map(litemap_path: Path | str = LITEMAP_PATH):
         'H1': '64', 'H2': '63', 'H3': '62', 'H4': '61', 'H5': '60', 'H6': '59', 'H7': '58', 'H8': '57',
     }
     # fmt: on
-    chip_type = int(caget(pv.me14e_gp1))
+    chip_type = int(caget(CHIPTYPE_PV))
     if chip_type in [ChipType.Oxford, ChipType.OxfordInner]:
         logger.info("Oxford Block Order")
         rows = ["A", "B", "C", "D", "E", "F", "G", "H"]
@@ -555,14 +566,14 @@ def load_lite_map(litemap_path: Path | str = LITEMAP_PATH):
                 label = "%02.d" % (lab_num + 1)
                 btn_names[button_name] = label
         block_dict = btn_names
+    else:
+        raise ValueError(f"{chip_type=} unrecognised")
 
-    litemap_path = _coerce_to_path(litemap_path)
-
-    litemap_fid = str(caget(pv.me14e_gp5)) + ".lite"
+    litemap_fid = f"{caget(MAP_FILEPATH_PV)}.lite"
     logger.info("Please wait, loading LITE map")
-    logger.info("Loading Lite Map")
-    logger.info("Opening %s" % (litemap_path / litemap_fid))
-    with open(litemap_path / litemap_fid, "r") as fh:
+    logger.debug("Loading Lite Map")
+    logger.info("Opening %s" % (LITEMAP_PATH / litemap_fid))
+    with open(LITEMAP_PATH / litemap_fid) as fh:
         f = fh.readlines()
     for line in f:
         entry = line.split()
@@ -570,151 +581,140 @@ def load_lite_map(litemap_path: Path | str = LITEMAP_PATH):
         yesno = entry[1]
         block_num = block_dict[block_name]
         pvar = "ME14E-MO-IOC-01:GP" + str(int(block_num) + 10)
-        logger.info("Block: %s \tScanned: %s \tPVAR: %s" % (block_name, yesno, pvar))
+        logger.info(f"Block: {block_name} \tScanned: {yesno} \tPVAR: {pvar}")
     logger.debug("Load lite map done")
+    yield from bps.null()
 
 
 @log.log_on_entry
-def load_full_map(fullmap_path: Path | str = FULLMAP_PATH):
-    (
-        chip_name,
-        visit,
-        sub_dir,
-        n_exposures,
-        chip_type,
-        map_type,
-    ) = startup.scrape_parameter_file()
-    fullmap_path = _coerce_to_path(fullmap_path)
-
-    fullmap_fid = fullmap_path / f"{str(caget(pv.me14e_gp5))}.spec"
-    logger.info("Opening %s" % fullmap_fid)
-    mapping.plot_file(fullmap_fid, chip_type)
-    mapping.convert_chip_to_hex(fullmap_fid, chip_type)
-    shutil.copy2(fullmap_fid.with_suffix(".full"), fullmap_path / "currentchip.full")
+def load_full_map() -> MsgGenerator:
+    setup_logging()
+    params = startup.read_parameter_file()
+
+    fullmap_fid = FULLMAP_PATH / f"{caget(MAP_FILEPATH_PV)}.spec"
+    logger.info(f"Opening {fullmap_fid}")
+    mapping.plot_file(fullmap_fid, params.chip.chip_type.value)
+    mapping.convert_chip_to_hex(fullmap_fid, params.chip.chip_type.value)
+    shutil.copy2(fullmap_fid.with_suffix(".full"), FULLMAP_PATH / "currentchip.full")
     logger.info(
-        "Copying %s to %s"
-        % (fullmap_fid.with_suffix(".full"), fullmap_path / "currentchip.full")
+        "Copying {} to {}".format(
+            fullmap_fid.with_suffix(".full"), FULLMAP_PATH / "currentchip.full"
+        )
     )
     logger.debug("Load full map done")
+    yield from bps.null()
 
 
 @log.log_on_entry
-def moveto(place: str = "origin"):
-    logger.info("Move to: %s" % place)
-    chip_type = int(caget(pv.me14e_gp1))
-    logger.info("Chip type is%s" % chip_type)
-
-    if chip_type == ChipType.Oxford or chip_type == ChipType.Minichip:
-        # Oxford and minichip
-        # As minichip is nothing more than a smaller oxford,
-        # they should move the same way
-        logger.info("Oxford Move")
-        if place == "origin":
-            caput(pv.me14e_stage_x, 0.0)
-            caput(pv.me14e_stage_y, 0.0)
-        if place == "f1":
-            caput(pv.me14e_stage_x, 25.40)
-            caput(pv.me14e_stage_y, 0.0)
-        if place == "f2":
-            caput(pv.me14e_stage_x, 0.0)
-            caput(pv.me14e_stage_y, 25.40)
-
-    elif chip_type == ChipType.OxfordInner:
-        logger.info("Oxford Inner Move")
-        if place == "origin":
-            caput(pv.me14e_stage_x, 0.0)
-            caput(pv.me14e_stage_y, 0.0)
-        if place == "f1":
-            caput(pv.me14e_stage_x, 24.60)
-            caput(pv.me14e_stage_y, 0.0)
-        if place == "f2":
-            caput(pv.me14e_stage_x, 0.0)
-            caput(pv.me14e_stage_y, 24.60)
-
-    elif chip_type == ChipType.Custom:
-        logger.info("Custom Chip Move")
-        if place == "origin":
-            caput(pv.me14e_stage_x, 0.0)
-            caput(pv.me14e_stage_y, 0.0)
-        if place == "f1":
-            caput(pv.me14e_stage_x, 25.40)
-            caput(pv.me14e_stage_y, 0.0)
-        if place == "f2":
-            caput(pv.me14e_stage_x, 0.0)
-            caput(pv.me14e_stage_y, 25.40)
-
-    else:
+def moveto(place: str = "origin", pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    setup_logging()
+    logger.info(f"Move to: {place}")
+    if place == Fiducials.zero:
+        logger.info("Chip aspecific move.")
+        yield from bps.trigger(pmac.to_xyz_zero)
+        return
+
+    chip_type = ChipType(int(caget(CHIPTYPE_PV)))
+    logger.info(f"Chip type is {chip_type}")
+    if chip_type not in list(ChipType):
         logger.warning("Unknown chip_type move")
+        return
+
+    logger.info(f"{str(chip_type)} Move")
+    chip_move = CHIP_MOVES[chip_type]
+
+    if place == Fiducials.origin:
+        yield from bps.mv(pmac.x, 0.0, pmac.y, 0.0)
+    if place == Fiducials.fid1:
+        yield from bps.mv(pmac.x, chip_move, pmac.y, 0.0)
+    if place == Fiducials.fid2:
+        yield from bps.mv(pmac.x, 0.0, pmac.y, chip_move)
+
+
+@log.log_on_entry
+def moveto_preset(
+    place: str,
+    pmac: PMAC = inject("pmac"),
+    beamstop: Beamstop = inject("beamstop"),
+    backlight: DualBacklight = inject("backlight"),
+    det_stage: DetectorMotion = inject("detector_motion"),
+) -> MsgGenerator:
+    setup_logging()
 
     # Non Chip Specific Move
     if place == "zero":
-        logger.info("Moving to %s" % place)
-        caput(pv.me14e_pmac_str, "!x0y0z0")
+        logger.info(f"Moving to {place}")
+        yield from bps.trigger(pmac.to_xyz_zero)
 
     elif place == "load_position":
         logger.info("load position")
-        caput(pv.bs_mp_select, "Robot")
-        caput(pv.bl_mp_select, "Out")
-        caput(pv.det_z, 1300)
+        yield from bps.abs_set(
+            beamstop.pos_select, BeamstopPositions.ROBOT, group=place
+        )
+        yield from bps.abs_set(backlight, BacklightPositions.OUT, group=place)
+        yield from bps.abs_set(det_stage.z, 1300, group=place)
+        yield from bps.wait(group=place)
 
     elif place == "collect_position":
         logger.info("collect position")
         caput(pv.me14e_filter, 20)
-        caput(pv.me14e_stage_x, 0.0)
-        caput(pv.me14e_stage_y, 0.0)
-        caput(pv.me14e_stage_z, 0.0)
-        caput(pv.bs_mp_select, "Data Collection")
-        caput(pv.bl_mp_select, "In")
+        yield from bps.mv(pmac.x, 0.0, pmac.y, 0.0, pmac.z, 0.0)
+        yield from bps.abs_set(
+            beamstop.pos_select, BeamstopPositions.DATA_COLLECTION, group=place
+        )
+        yield from bps.abs_set(backlight, BacklightPositions.IN, group=place)
+        yield from bps.wait(group=place)
 
     elif place == "microdrop_position":
         logger.info("microdrop align position")
-        caput(pv.me14e_stage_x, 6.0)
-        caput(pv.me14e_stage_y, -7.8)
-        caput(pv.me14e_stage_z, 0.0)
+        yield from bps.mv(pmac.x, 6.0, pmac.y, -7.8, pmac.z, 0.0)
 
-    elif place == "laser1on":  # these are in laser edm
+
+@log.log_on_entry
+def laser_control(laser_setting: str, pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    setup_logging()
+    logger.info(f"Move to: {laser_setting}")
+    if laser_setting == "laser1on":  # these are in laser edm
         logger.info("Laser 1 /BNC2 shutter is open")
         # Use M712 = 0 if triggering on falling edge. M712 =1 if on rising edge
         # Be sure to also change laser1off
         # caput(pv.me14e_pmac_str, ' M712=0 M711=1')
-        caput(pv.me14e_pmac_str, " M712=1 M711=1")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_1_ON, wait=True)
 
-    elif place == "laser1off":
+    elif laser_setting == "laser1off":
         logger.info("Laser 1 shutter is closed")
-        caput(pv.me14e_pmac_str, " M712=0 M711=1")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_1_OFF, wait=True)
 
-    elif place == "laser2on":
+    elif laser_setting == "laser2on":
         logger.info("Laser 2 / BNC3 shutter is open")
-        caput(pv.me14e_pmac_str, " M812=1 M811=1")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_2_ON, wait=True)
 
-    elif place == "laser2off":
+    elif laser_setting == "laser2off":
         logger.info("Laser 2 shutter is closed")
-        caput(pv.me14e_pmac_str, " M812=0 M811=1")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_2_OFF, wait=True)
 
-    elif place == "laser1burn":
+    elif laser_setting == "laser1burn":
         led_burn_time = caget(pv.me14e_gp103)
         logger.info("Laser 1  on")
-        logger.info("Burn time is %s s" % led_burn_time)
-        caput(pv.me14e_pmac_str, " M712=1 M711=1")
-        sleep(int(float(led_burn_time)))
+        logger.info(f"Burn time is {led_burn_time} s")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_1_ON, wait=True)
+        yield from bps.sleep(led_burn_time)
         logger.info("Laser 1 off")
-        caput(pv.me14e_pmac_str, " M712=0 M711=1")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_1_OFF, wait=True)
 
-    elif place == "laser2burn":
+    elif laser_setting == "laser2burn":
         led_burn_time = caget(pv.me14e_gp109)
         logger.info("Laser 2 on")
-        logger.info("burntime %s s" % led_burn_time)
-        caput(pv.me14e_pmac_str, " M812=1 M811=1")
-        sleep(int(float(led_burn_time)))
+        logger.info(f"burntime {led_burn_time} s")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_2_ON, wait=True)
+        yield from bps.sleep(led_burn_time)
         logger.info("Laser 2 off")
-        caput(pv.me14e_pmac_str, " M812=0 M811=1")
+        yield from bps.abs_set(pmac.laser, LaserSettings.LASER_2_OFF, wait=True)
 
 
 @log.log_on_entry
-def scrape_mtr_directions(param_path: Path | str = CS_FILES_PATH):
-    param_path = _coerce_to_path(param_path)
-
-    with open(param_path / "motor_direction.txt", "r") as f:
+def scrape_mtr_directions(motor_file_path: Path = CS_FILES_PATH):
+    with open(motor_file_path / "motor_direction.txt") as f:
         lines = f.readlines()
     mtr1_dir, mtr2_dir, mtr3_dir = 1.0, 1.0, 1.0
     for line in lines:
@@ -726,62 +726,57 @@ def scrape_mtr_directions(param_path: Path | str = CS_FILES_PATH):
             mtr3_dir = float(line.split("=")[1])
         else:
             continue
-    logger.info("mt1_dir %s mtr2_dir %s mtr3_dir %s" % (mtr1_dir, mtr2_dir, mtr3_dir))
+    logger.debug(f"mt1_dir {mtr1_dir} mtr2_dir {mtr2_dir} mtr3_dir {mtr3_dir}")
     return mtr1_dir, mtr2_dir, mtr3_dir
 
 
 @log.log_on_entry
-def fiducial(point: int = 1, param_path: Path | str = CS_FILES_PATH):
+def fiducial(point: int = 1, pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    setup_logging()
     scale = 10000.0  # noqa: F841
-    param_path = _coerce_to_path(param_path)
-
-    mtr1_dir, mtr2_dir, mtr3_dir = scrape_mtr_directions(param_path)
 
-    rbv_1 = float(caget(pv.me14e_stage_x + ".RBV"))
-    rbv_2 = float(caget(pv.me14e_stage_y + ".RBV"))
-    rbv_3 = float(caget(pv.me14e_stage_z + ".RBV"))
+    mtr1_dir, mtr2_dir, mtr3_dir = scrape_mtr_directions(CS_FILES_PATH)
 
-    raw_1 = float(caget(pv.me14e_stage_x + ".RRBV"))
-    raw_2 = float(caget(pv.me14e_stage_y + ".RRBV"))
-    raw_3 = float(caget(pv.me14e_stage_z + ".RRBV"))
+    rbv_1 = yield from bps.rd(pmac.x.user_readback)
+    rbv_2 = yield from bps.rd(pmac.y.user_readback)
+    rbv_3 = yield from bps.rd(pmac.z.user_readback)
 
-    f_x = rbv_1
-    f_y = rbv_2
-    f_z = rbv_3
-
-    logger.info("Writing Fiducial File %s/fiducial_%s.txt" % (param_path, point))
+    output_param_path = PARAM_FILE_PATH_FT
+    output_param_path.mkdir(parents=True, exist_ok=True)
+    logger.info(f"Writing Fiducial File {output_param_path}/fiducial_{point}.txt")
     logger.info("MTR\tRBV\tRAW\tCorr\tf_value")
-    logger.info("MTR1\t%1.4f\t%i\t%i\t%1.4f" % (rbv_1, raw_1, mtr1_dir, f_x))
-    logger.info("MTR2\t%1.4f\t%i\t%i\t%1.4f" % (rbv_2, raw_2, mtr2_dir, f_y))
-    logger.info("MTR3\t%1.4f\t%i\t%i\t%1.4f" % (rbv_3, raw_3, mtr3_dir, f_z))
-
-    with open(param_path / f"fiducial_{point}.txt", "w") as f:
-        f.write("MTR\tRBV\tRAW\tCorr\tf_value\n")
-        f.write("MTR1\t%1.4f\t%i\t%i\t%1.4f\n" % (rbv_1, raw_1, mtr1_dir, f_x))
-        f.write("MTR2\t%1.4f\t%i\t%i\t%1.4f\n" % (rbv_2, raw_2, mtr2_dir, f_y))
-        f.write("MTR3\t%1.4f\t%i\t%i\t%1.4f" % (rbv_3, raw_3, mtr3_dir, f_z))
+    logger.info("MTR1\t%1.4f\t%i" % (rbv_1, mtr1_dir))
+    logger.info("MTR2\t%1.4f\t%i" % (rbv_2, mtr2_dir))
+    logger.info("MTR3\t%1.4f\t%i" % (rbv_3, mtr3_dir))
+
+    with open(output_param_path / f"fiducial_{point}.txt", "w") as f:
+        f.write("MTR\tRBV\tCorr\n")
+        f.write("MTR1\t%1.4f\t%i\n" % (rbv_1, mtr1_dir))
+        f.write("MTR2\t%1.4f\t%i\n" % (rbv_2, mtr2_dir))
+        f.write("MTR3\t%1.4f\t%i" % (rbv_3, mtr3_dir))
     logger.info(f"Fiducial {point} set.")
+    yield from bps.null()
 
 
-def scrape_mtr_fiducials(point: int, param_path: Path | str = CS_FILES_PATH):
-    param_path = _coerce_to_path(param_path)
-
-    with open(param_path / f"fiducial_{point}.txt", "r") as f:
+def scrape_mtr_fiducials(
+    point: int, param_path: Path = PARAM_FILE_PATH_FT
+) -> tuple[float, float, float]:
+    with open(param_path / f"fiducial_{point}.txt") as f:
         f_lines = f.readlines()[1:]
-    f_x = float(f_lines[0].rsplit()[4])
-    f_y = float(f_lines[1].rsplit()[4])
-    f_z = float(f_lines[2].rsplit()[4])
+    f_x = float(f_lines[0].rsplit()[1])
+    f_y = float(f_lines[1].rsplit()[1])
+    f_z = float(f_lines[2].rsplit()[1])
     return f_x, f_y, f_z
 
 
 @log.log_on_entry
-def cs_maker():
+def cs_maker(pmac: PMAC = inject("pmac")) -> MsgGenerator:
     """
     Coordinate system.
 
     Values for scalex, scaley, scalez, and skew, as well as the sign of
     Sx, Sy, Sz are stored in a .json file and should be modified there.
-    Location of file: src/mx_bluesky/I24/serial/parameters/cs_maker.json
+    Location of file: src/mx_bluesky/i24/serial/parameters/cs_maker.json
 
     Theory
     Rx: rotation about X-axis, pitch
@@ -805,24 +800,25 @@ def cs_maker():
     This should be measured in situ prior to expriment, ie. measure by hand using
     opposite and adjacent RBV after calibration of scale factors.
     """
-    chip_type = int(caget(pv.me14e_gp1))
+    setup_logging()
+    chip_type = int(caget(CHIPTYPE_PV))
     fiducial_dict = {}
     fiducial_dict[0] = [25.400, 25.400]
     fiducial_dict[1] = [24.600, 24.600]
     fiducial_dict[2] = [25.400, 25.400]
     fiducial_dict[3] = [18.25, 18.25]
-    logger.info("Chip type is %s with size %s" % (chip_type, fiducial_dict[chip_type]))
+    logger.info(f"Chip type is {chip_type} with size {fiducial_dict[chip_type]}")
 
     mtr1_dir, mtr2_dir, mtr3_dir = scrape_mtr_directions()
     f1_x, f1_y, f1_z = scrape_mtr_fiducials(1)
     f2_x, f2_y, f2_z = scrape_mtr_fiducials(2)
-    logger.info("mtr1 direction: %s" % mtr1_dir)
-    logger.info("mtr2 direction: %s" % mtr2_dir)
-    logger.info("mtr3 direction: %s" % mtr3_dir)
+    logger.info(f"mtr1 direction: {mtr1_dir}")
+    logger.info(f"mtr2 direction: {mtr2_dir}")
+    logger.info(f"mtr3 direction: {mtr3_dir}")
 
     # Scale parameters saved in json file
     try:
-        with open(CS_FILES_PATH / "cs_maker.json", "r") as fh:
+        with open(CS_FILES_PATH / "cs_maker.json") as fh:
             cs_info = json.load(fh)
     except json.JSONDecodeError:
         logger.error("Invalid JSON file.")
@@ -857,22 +853,22 @@ def cs_maker():
     Sz1 = -1 * f1_y / fiducial_dict[chip_type][0]
     Sz2 = f2_x / fiducial_dict[chip_type][1]
     Sz = Sz_dir * ((Sz1 + Sz2) / 2)
-    Cz = np.sqrt((1 - Sz**2))
-    logger.info("Sz1 , %1.4f, %1.4f" % (Sz1, np.degrees(np.arcsin(Sz1))))
-    logger.info("Sz2 , %1.4f, %1.4f" % (Sz2, np.degrees(np.arcsin(Sz2))))
-    logger.info("Sz , %1.4f, %1.4f" % (Sz, np.degrees(np.arcsin(Sz))))
-    logger.info("Cz , %1.4f, %1.4f" % (Cz, np.degrees(np.arcsin(Cz))))
+    Cz = np.sqrt(1 - Sz**2)
+    logger.info(f"Sz1 , {Sz1:1.4f}, {np.degrees(np.arcsin(Sz1)):1.4f}")
+    logger.info(f"Sz2 , {Sz2:1.4f}, {np.degrees(np.arcsin(Sz2)):1.4f}")
+    logger.info(f"Sz , {Sz:1.4f}, {np.degrees(np.arcsin(Sz)):1.4f}")
+    logger.info(f"Cz , {Cz:1.4f}, {np.degrees(np.arcsin(Cz)):1.4f}")
     # Rotation Around Y
     Sy = Sy_dir * f1_z / fiducial_dict[chip_type][0]
-    Cy = np.sqrt((1 - Sy**2))
-    logger.info("Sy , %1.4f, %1.4f" % (Sy, np.degrees(np.arcsin(Sy))))
-    logger.info("Cy , %1.4f, %1.4f" % (Cy, np.degrees(np.arcsin(Cy))))
+    Cy = np.sqrt(1 - Sy**2)
+    logger.info(f"Sy , {Sy:1.4f}, {np.degrees(np.arcsin(Sy)):1.4f}")
+    logger.info(f"Cy , {Cy:1.4f}, {np.degrees(np.arcsin(Cy)):1.4f}")
     # Rotation Around X
     # If stages upsidedown (I24) change sign of Sx
     Sx = Sx_dir * f2_z / fiducial_dict[chip_type][1]
-    Cx = np.sqrt((1 - Sx**2))
-    logger.info("Sx , %1.4f, %1.4f" % (Sx, np.degrees(np.arcsin(Sx))))
-    logger.info("Cx , %1.4f, %1.4f" % (Cx, np.degrees(np.arcsin(Cx))))
+    Cx = np.sqrt(1 - Sx**2)
+    logger.info(f"Sx , {Sx:1.4f}, {np.degrees(np.arcsin(Sx)):1.4f}")
+    logger.info(f"Cx , {Cx:1.4f}, {np.degrees(np.arcsin(Cx)):1.4f}")
 
     x1factor = mtr1_dir * scalex * (Cy * Cz)
     y1factor = mtr2_dir * scaley * (-1.0 * Cx * Sz)
@@ -886,14 +882,14 @@ def cs_maker():
     y3factor = mtr2_dir * scaley * ((Cx * Sy * Sz) + (Sx * Cz))
     z3factor = mtr3_dir * scalez * (Cx * Cy)
 
-    logger.info("Skew being used is: %1.4f" % skew)
+    logger.info(f"Skew being used is: {skew:1.4f}")
     s1 = np.degrees(np.arcsin(Sz1))
     s2 = np.degrees(np.arcsin(Sz2))
     rot = np.degrees(np.arcsin((Sz1 + Sz2) / 2))
     calc_skew = (s1 - rot) - (s2 - rot)
-    logger.info("s1:%1.4f s2:%1.4f rot:%1.4f" % (s1, s2, rot))
-    logger.info("Calculated rotation from current fiducials is: %1.4f" % rot)
-    logger.info("Calculated Skew from current fiducials is: %1.4f" % calc_skew)
+    logger.info(f"s1:{s1:1.4f} s2:{s2:1.4f} rot:{rot:1.4f}")
+    logger.info(f"Calculated rotation from current fiducials is: {rot:1.4f}")
+    logger.info(f"Calculated Skew from current fiducials is: {calc_skew:1.4f}")
     logger.info("Calculated Skew has been known to have the wrong sign")
 
     sinD = np.sin((skew / 2) * (np.pi / 180))
@@ -903,10 +899,10 @@ def cs_maker():
     new_x2factor = (x2factor * cosD) + (y2factor * sinD)
     new_y2factor = (x2factor * sinD) + (y2factor * cosD)
 
-    cs1 = "#1->%+1.3fX%+1.3fY%+1.3fZ" % (new_x1factor, new_y1factor, z1factor)
-    cs2 = "#2->%+1.3fX%+1.3fY%+1.3fZ" % (new_x2factor, new_y2factor, z2factor)
-    cs3 = "#3->%+1.3fX%+1.3fY%+1.3fZ" % (x3factor, y3factor, z3factor)
-    logger.info("PMAC strings. \ncs1: %s \ncs2: %scs3: %s" % (cs1, cs2, cs3))
+    cs1 = f"#1->{new_x1factor:+1.3f}X{new_y1factor:+1.3f}Y{z1factor:+1.3f}Z"
+    cs2 = f"#2->{new_x2factor:+1.3f}X{new_y2factor:+1.3f}Y{z2factor:+1.3f}Z"
+    cs3 = f"#3->{x3factor:+1.3f}X{y3factor:+1.3f}Y{z3factor:+1.3f}Z"
+    logger.info(f"PMAC strings. \ncs1: {cs1} \ncs2: {cs2}cs3: {cs3}")
     logger.info(
         """These next values should be 1.
         This is the sum of the squares of the factors divided by their scale."""
@@ -914,52 +910,70 @@ def cs_maker():
     sqfact1 = np.sqrt(x1factor**2 + y1factor**2 + z1factor**2) / scalex
     sqfact2 = np.sqrt(x2factor**2 + y2factor**2 + z2factor**2) / scaley
     sqfact3 = np.sqrt(x3factor**2 + y3factor**2 + z3factor**2) / scalez
-    logger.info("%1.4f \n %1.4f \n %1.4f" % (sqfact1, sqfact2, sqfact3))
-    logger.info("Long wait, please be patient")
-    caput(pv.me14e_pmac_str, "!x0y0z0")
+    logger.info(f"{sqfact1:1.4f} \n {sqfact2:1.4f} \n {sqfact3:1.4f}")
+    logger.debug("Long wait, please be patient")
+    yield from bps.trigger(pmac.to_xyz_zero)
     sleep(2.5)
-    caput(pv.me14e_pmac_str, "&2")
-    caput(pv.me14e_pmac_str, cs1)
-    caput(pv.me14e_pmac_str, cs2)
-    caput(pv.me14e_pmac_str, cs3)
-    caput(pv.me14e_pmac_str, "!x0y0z0")
+    yield from set_pmac_strings_for_cs(pmac, {"cs1": cs1, "cs2": cs2, "cs3": cs3})
+    yield from bps.trigger(pmac.to_xyz_zero)
     sleep(0.1)
-    caput(pv.me14e_pmac_str, "#1hmz#2hmz#3hmz")
+    yield from bps.trigger(pmac.home, wait=True)
     sleep(0.1)
-    logger.info("Chip_type is %s" % chip_type)
+    logger.debug(f"Chip_type is {chip_type}")
     if chip_type == 0:
-        caput(pv.me14e_pmac_str, "!x0.4y0.4")
+        yield from bps.abs_set(pmac.pmac_string, "!x0.4y0.4", wait=True)
         sleep(0.1)
-        caput(pv.me14e_pmac_str, "#1hmz#2hmz#3hmz")
+        yield from bps.trigger(pmac.home, wait=True)
     else:
-        caput(pv.me14e_pmac_str, "#1hmz#2hmz#3hmz")
+        yield from bps.trigger(pmac.home, wait=True)
     logger.debug("CSmaker done.")
+    yield from bps.null()
 
 
-def cs_reset():
-    cs1 = "#1->-10000X+0Y+0Z"
-    cs2 = "#2->+0X+10000Y+0Z"
-    cs3 = "#3->0X+0Y+10000Z"
+def cs_reset(pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    """Used to clear CS when using Custom Chip"""
+    setup_logging()
+    cs1 = "#1->10000X+0Y+0Z"
+    cs2 = "#2->+0X-10000Y+0Z"
+    cs3 = "#3->0X+0Y-10000Z"
     strg = "\n".join([cs1, cs2, cs3])
     print(strg)
-    caput(pv.me14e_pmac_str, "&2")
-    sleep(0.5)
-    caput(pv.me14e_pmac_str, cs1)
-    sleep(0.5)
-    caput(pv.me14e_pmac_str, cs2)
-    sleep(0.5)
-    caput(pv.me14e_pmac_str, cs3)
+    yield from set_pmac_strings_for_cs(pmac, {"cs1": cs1, "cs2": cs2, "cs3": cs3})
     logger.debug("CSreset Done")
+    yield from bps.null()
+
+
+def set_pmac_strings_for_cs(pmac: PMAC, cs_str: dict):
+    """ A plan to set the pmac_string for the (x,y,z) axes while making or resetting \
+        the coordinate system.
+
+    Args:
+        pmac (PMAC): PMAC device
+        cs_str (dict): A dictionary containing a string for each axis, in the format: \
+            {
+                "cs1": "#1->1X+0Y+0Z",
+                "cs2": "#2->...",
+                "cs3": "#3->...",
+            }
+
+    Note. On the PMAC the axes allocations are: #1 - X, #2 - Y, #3 - Z.
+    """
+    yield from bps.abs_set(pmac.pmac_string, "&2", wait=True)
+    yield from bps.abs_set(pmac.pmac_string, cs_str["cs1"], wait=True)
+    yield from bps.abs_set(pmac.pmac_string, cs_str["cs2"], wait=True)
+    yield from bps.abs_set(pmac.pmac_string, cs_str["cs3"], wait=True)
 
 
 @log.log_on_entry
-def pumpprobe_calc():
+def pumpprobe_calc() -> MsgGenerator:
+    # TODO See https://github.com/DiamondLightSource/mx_bluesky/issues/122
+    setup_logging()
     logger.info("Calculate and show exposure and dwell time for each option.")
     exptime = float(caget(pv.me14e_exptime))
     pumpexptime = float(caget(pv.me14e_gp103))
     movetime = 0.008
-    logger.info("X-ray exposure time %s" % exptime)
-    logger.info("Laser dwell time %s" % pumpexptime)
+    logger.info(f"X-ray exposure time {exptime}")
+    logger.info(f"Laser dwell time {pumpexptime}")
     repeat1 = 2 * 20 * (movetime + (pumpexptime + exptime) / 2)
     repeat2 = 4 * 20 * (movetime + (pumpexptime + exptime) / 2)
     repeat3 = 6 * 20 * (movetime + (pumpexptime + exptime) / 2)
@@ -974,17 +988,19 @@ def pumpprobe_calc():
     ):
         rounded = round(repeat, 4)
         caput(pv_name, rounded)
-        logger.info("Repeat (%s): %s s" % (pv_name, rounded))
-    # logger.info("repeat10 (%s): %s s" % (pv.me14e_gp108, round(repeat10, 4)))
+        logger.info(f"Repeat ({pv_name}): {rounded} s")
     logger.debug("PP calculations done")
+    yield from bps.null()
 
 
 @log.log_on_entry
-def block_check():
+def block_check(pmac: PMAC = inject("pmac")) -> MsgGenerator:
+    setup_logging()
+    # TODO See https://github.com/DiamondLightSource/mx_bluesky/issues/117
     caput(pv.me14e_gp9, 0)
     while True:
         if int(caget(pv.me14e_gp9)) == 0:
-            chip_type = int(caget(pv.me14e_gp1))
+            chip_type = int(caget(CHIPTYPE_PV))
             if chip_type == ChipType.Minichip:
                 logger.info("Oxford mini chip in use.")
                 block_start_list = scrape_pvar_file("minichip_oxford.pvar")
@@ -1003,72 +1019,17 @@ def block_check():
                     sleep(1.0)
                     break
                 block, x, y = entry
-                logger.info("Block: %s -> (x=%s y=%s)" % (block, x, y))
-                caput(pv.me14e_pmac_str, "!x%sy%s" % (x, y))
+                logger.debug(f"Block: {block} -> (x={x} y={y})")
+                yield from bps.abs_set(pmac.pmac_string, f"!x{x}y{y}", wait=True)
                 time.sleep(0.4)
         else:
             logger.warning("Block Check Aborted due to GP 9 not equalling 0")
             break
         break
     logger.debug("Block check done")
+    yield from bps.null()
 
 
-def parse_args_and_run_parsed_function(args):
-    print(f"Run with {args}")
-    parser = argparse.ArgumentParser()
-    subparsers = parser.add_subparsers(
-        help="Choose command.",
-        required=True,
-        dest="sub-command",
-    )
-    parser_init = subparsers.add_parser(
-        "initialise",
-    )
-    parser_init.set_defaults(func=initialise)
-    parser_moveto = subparsers.add_parser(
-        "moveto",
-    )
-    parser_moveto.add_argument("place", type=str)
-    parser_moveto.set_defaults(func=moveto)
-    parser_fid = subparsers.add_parser("fiducial")
-    parser_fid.add_argument("point", type=int)
-    parser_fid.set_defaults(func=fiducial)
-    parser_csm = subparsers.add_parser("cs_maker")
-    parser_csm.set_defaults(func=cs_maker)
-    parser_pp = subparsers.add_parser("pumpprobe_calc")
-    parser_pp.set_defaults(func=pumpprobe_calc)
-    parser_write = subparsers.add_parser("write_parameter_file")
-    parser_write.set_defaults(func=write_parameter_file)
-    parser_def = subparsers.add_parser("define_current_chip")
-    parser_def.add_argument("chipid", type=str)
-    parser_def.set_defaults(func=define_current_chip)
-    parser_stockmap = subparsers.add_parser("load_stock_map")
-    parser_stockmap.add_argument("map_choice", type=str)
-    parser_stockmap.set_defaults(func=load_stock_map)
-    parser_litemap = subparsers.add_parser("load_lite_map")
-    parser_litemap.set_defaults(func=load_lite_map)
-    parser_fullmap = subparsers.add_parser("load_full_map")
-    parser_fullmap.set_defaults(func=load_full_map)
-    parser_save = subparsers.add_parser("save_screen_map")
-    parser_save.set_defaults(func=save_screen_map)
-    parser_upld = subparsers.add_parser("upload_full")
-    parser_upld.set_defaults(func=upload_full)
-    parser_params = subparsers.add_parser("upload_parameters")
-    parser_params.add_argument("chipid", type=str)
-    parser_params.set_defaults(func=upload_parameters)
-    parser_csr = subparsers.add_parser("cs_reset")
-    parser_csr.set_defaults(func=cs_reset)
-    parser_block = subparsers.add_parser("block_check")
-    parser_block.set_defaults(func=block_check)
-
-    args = parser.parse_args(args)
-
-    args_dict = vars(args)
-    args_dict.pop("sub-command")
-    args_dict.pop("func")(**args_dict)
-
-
-if __name__ == "__main__":
-    setup_logging()
-
-    parse_args_and_run_parsed_function(sys.argv[1:])
+# setup_logging now called in all functions.
+# TODO See logging issue on blueapi
+# https://github.com/DiamondLightSource/blueapi/issues/494