pychemstation 0.4.7.dev1__tar.gz → 0.4.7.dev3__tar.gz

{pychemstation-0.4.7.dev1 → pychemstation-0.4.7.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pychemstation
-Version: 0.4.7.dev1
+Version: 0.4.7.dev3
 Summary: Library to interact with Chemstation software, primarily used in Hein lab
 Home-page: https://gitlab.com/heingroup/pychemstation
 Author: Lucy Hao
@@ -15,8 +15,9 @@ Requires-Dist: seabreeze
 
 # Agilent HPLC Macro Control
 
-[![PyPI Downloads](https://img.shields.io/pypi/dm/hein-analytical-control.svg?label=PyPI%20downloads)](https://pypi.org/project/hein-analytical-control)
-[![PyPI Latest Release](https://img.shields.io/pypi/v/hein-analytical-control.svg)](https://pypi.org/project/hein-analytical-control/)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/pychemstation)
+
+[![PyPI Latest Release](https://img.shields.io/pypi/v/pychemstation.svg)](https://pypi.org/project/pychemstation/)
 
 Unofficial Python package to control Agilent Chemstation; we are not affiliated with Agilent.
 Check out the [docs](https://hein-analytical-control-5e6e85.gitlab.io/) for usage instructions. This project is under
@@ -58,7 +59,7 @@ HPLCTalk_Run
 ## Example Usage
 
 ```python
-from pychemstation.control import HPLCController
+from pychemstation.control import HPLCController, MethodController, SequenceController
 import pandas as pd
 
 # these paths will be unique to your Chemstation setup
@@ -67,17 +68,17 @@ DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\hplc-method-optimization\\tests"
 
 hplc_controller = HPLCController(data_dir=DATA_DIR,
-                                 comm_dir=DEFAULT_COMMAND_PATH,
-                                 method_dir=DEFAULT_METHOD_DIR)
+                                 comm_dir=DEFAULT_COMMAND_PATH)
+method_controller = MethodController(controller=hplc_controller,
+                                     src=DEFAULT_METHOD_DIR)
 
 hplc_controller.preprun()
-hplc_controller.switch_method(method_name="General-Poroshell")
-hplc_controller.run_method(experiment_name="Run 10")
-data_ready = hplc_controller.check_hplc_ready_with_data()
+method_controller.switch(method_name="General-Poroshell")
+method_controller.run(experiment_name="Run 10")
+data_ready = method_controller.data_ready()
 
 if data_ready:
-    hplc_controller.get_spectrum()
-    chrom = hplc_controller.spectra["A"]
+    chrom = method_controller.get_data()
     # afterwards, save, analyze or plot the data!
     values = {"x": chrom.x, "y": chrom.y}
     chromatogram_data = pd.DataFrame.from_dict(values)
@@ -92,7 +93,7 @@ put the file in the `user.mac` file and then list the function you want to use.
 ## Developing
 
 If you would like to contribute to this project, check out
-our [GitLab](https://gitlab.com/heingroup/hein-analytical-control)!
+our [GitLab](https://gitlab.com/heingroup/device-api/pychemstation)!
 
 ## Authors and Acknowledgements
 

{pychemstation-0.4.7.dev1 → pychemstation-0.4.7.dev3}/README.md

@@ -1,7 +1,8 @@
 # Agilent HPLC Macro Control
 
-[![PyPI Downloads](https://img.shields.io/pypi/dm/hein-analytical-control.svg?label=PyPI%20downloads)](https://pypi.org/project/hein-analytical-control)
-[![PyPI Latest Release](https://img.shields.io/pypi/v/hein-analytical-control.svg)](https://pypi.org/project/hein-analytical-control/)
+![PyPI - Downloads](https://img.shields.io/pypi/dm/pychemstation)
+
+[![PyPI Latest Release](https://img.shields.io/pypi/v/pychemstation.svg)](https://pypi.org/project/pychemstation/)
 
 Unofficial Python package to control Agilent Chemstation; we are not affiliated with Agilent.
 Check out the [docs](https://hein-analytical-control-5e6e85.gitlab.io/) for usage instructions. This project is under
@@ -43,7 +44,7 @@ HPLCTalk_Run
 ## Example Usage
 
 ```python
-from pychemstation.control import HPLCController
+from pychemstation.control import HPLCController, MethodController, SequenceController
 import pandas as pd
 
 # these paths will be unique to your Chemstation setup
@@ -52,17 +53,17 @@ DATA_DIR = "C:\\Users\\Public\\Documents\\ChemStation\\2\\Data"
 DEFAULT_COMMAND_PATH = "C:\\Users\\User\\Desktop\\Lucy\\hplc-method-optimization\\tests"
 
 hplc_controller = HPLCController(data_dir=DATA_DIR,
-                                 comm_dir=DEFAULT_COMMAND_PATH,
-                                 method_dir=DEFAULT_METHOD_DIR)
+                                 comm_dir=DEFAULT_COMMAND_PATH)
+method_controller = MethodController(controller=hplc_controller,
+                                     src=DEFAULT_METHOD_DIR)
 
 hplc_controller.preprun()
-hplc_controller.switch_method(method_name="General-Poroshell")
-hplc_controller.run_method(experiment_name="Run 10")
-data_ready = hplc_controller.check_hplc_ready_with_data()
+method_controller.switch(method_name="General-Poroshell")
+method_controller.run(experiment_name="Run 10")
+data_ready = method_controller.data_ready()
 
 if data_ready:
-    hplc_controller.get_spectrum()
-    chrom = hplc_controller.spectra["A"]
+    chrom = method_controller.get_data()
     # afterwards, save, analyze or plot the data!
     values = {"x": chrom.x, "y": chrom.y}
     chromatogram_data = pd.DataFrame.from_dict(values)
@@ -77,7 +78,7 @@ put the file in the `user.mac` file and then list the function you want to use.
 ## Developing
 
 If you would like to contribute to this project, check out
-our [GitLab](https://gitlab.com/heingroup/hein-analytical-control)!
+our [GitLab](https://gitlab.com/heingroup/device-api/pychemstation)!
 
 ## Authors and Acknowledgements
 

pychemstation-0.4.7.dev3/pychemstation/control/__init__.py

@@ -0,0 +1,6 @@
+"""
+.. include:: README.md
+"""
+from .comm import HPLCController
+from .method import MethodController
+from .sequence import SequenceController

pychemstation-0.4.7.dev3/pychemstation/control/comm.py

@@ -0,0 +1,276 @@
+"""
+Module to provide API for the remote control of the Agilent HPLC systems.
+
+HPLCController sends commands to Chemstation software via a command file.
+Answers are received via reply file. On the Chemstation side, a custom
+Macro monitors the command file, executes commands and writes to the reply file.
+Each command is given a number (cmd_no) to keep track of which commands have
+been processed.
+
+Authors: Alexander Hammer, Hessam Mehr, Lucy Hao
+"""
+
+import logging
+import os
+import time
+
+import polling
+
+from ..utils.chromatogram import AgilentHPLCChromatogram
+from ..utils.constants import MAX_CMD_NO
+from ..utils.macro import *
+from ..utils.method_types import *
+
+
+class HPLCController:
+    """
+    Class to control Agilent HPLC systems via Chemstation Macros.
+    """
+
+    def __init__(
+            self,
+            comm_dir: str,
+            data_dir: str,
+            cmd_file: str = "cmd",
+            reply_file: str = "reply",
+    ):
+        """Initialize HPLC controller. The `hplc_talk.mac` macro file must be loaded in the Chemstation software.
+        `comm_dir` must match the file path in the macro file.
+        
+        :param comm_dir: Name of directory for communication, where ChemStation will read and write from. Can be any existing directory.
+        :param data_dir: Name of directory that ChemStation saves run data. Must be accessible by ChemStation.
+        :param cmd_file: Name of command file
+        :param reply_file: Name of reply file
+        :raises FileNotFoundError: If either `data_dir`, `method_dir` or `comm_dir` is not a valid directory.
+        """
+        if os.path.isdir(comm_dir):
+            self.cmd_file = os.path.join(comm_dir, cmd_file)
+            self.reply_file = os.path.join(comm_dir, reply_file)
+            self.cmd_no = 0
+        else:
+            raise FileNotFoundError(f"comm_dir: {comm_dir} not found.")
+        self._most_recent_hplc_status = None
+
+        if os.path.isdir(data_dir):
+            self.data_dir = data_dir
+        else:
+            raise FileNotFoundError(f"data_dir: {data_dir} not found.")
+
+        self.spectra = {
+            "A": AgilentHPLCChromatogram(self.data_dir),
+            "B": AgilentHPLCChromatogram(self.data_dir),
+            "C": AgilentHPLCChromatogram(self.data_dir),
+            "D": AgilentHPLCChromatogram(self.data_dir),
+        }
+
+        self.data_files: list[str] = []
+        self.internal_variables: list[dict[str, str]] = []
+
+        # Create files for Chemstation to communicate with Python
+        open(self.cmd_file, "a").close()
+        open(self.reply_file, "a").close()
+
+        self.logger = logging.getLogger("hplc_logger")
+        self.logger.addHandler(logging.NullHandler())
+
+        self.reset_cmd_counter()
+
+        self.logger.info("HPLC Controller initialized.")
+
+    def _set_status(self):
+        """Updates current status of HPLC machine"""
+        self._most_recent_hplc_status = self.status()[0]
+
+    def _check_data_status(self) -> bool:
+        """Checks if HPLC machine is in an available state, meaning a state that data is not being written.
+
+        :return: whether the HPLC machine is in a safe state to retrieve data back."""
+        old_status = self._most_recent_hplc_status
+        self._set_status()
+        file_exists = os.path.exists(self.data_files[-1]) if len(self.data_files) > 0 else False
+        done_writing_data = isinstance(self._most_recent_hplc_status,
+                                       HPLCAvailStatus) and old_status != self._most_recent_hplc_status and file_exists
+        return done_writing_data
+
+    def check_hplc_ready_with_data(self) -> bool:
+        """Checks if ChemStation has finished writing data and can be read back.
+
+        :param method: if you are running a method and want to read back data, the timeout period will be adjusted to be longer than the method's runtime
+
+        :return: Return True if data can be read back, else False.
+        """
+        self._set_status()
+
+        timeout = 10 * 60
+        hplc_run_done = polling.poll(
+            lambda: self._check_data_status(),
+            timeout=timeout,
+            step=30
+        )
+
+        return hplc_run_done
+
+    def get_spectrum(self):
+        """ Load last chromatogram for any channel in spectra dictionary."""
+        last_file = self.data_files[-1] if len(self.data_files) > 0 else None
+
+        if last_file is None:
+            raise IndexError
+
+        for channel, spec in self.controller.spectra.items():
+            spec.load_spectrum(data_path=last_file, channel=channel)
+            self.logger.info("%s chromatogram loaded.", channel)
+
+    def _send(self, cmd: str, cmd_no: int, num_attempts=5) -> None:
+        """Low-level execution primitive. Sends a command string to HPLC.
+
+        :param cmd: string to be sent to HPLC
+        :param cmd_no: Command number
+        :param num_attempts: Number of attempts to send the command before raising exception.
+        :raises IOError: Could not write to command file.
+        """
+        err = None
+        for _ in range(num_attempts):
+            time.sleep(1)
+            try:
+                with open(self.cmd_file, "w", encoding="utf8") as cmd_file:
+                    cmd_file.write(f"{cmd_no} {cmd}")
+            except IOError as e:
+                err = e
+                self.logger.warning("Failed to send command; trying again.")
+                continue
+            else:
+                self.logger.info("Sent command #%d: %s.", cmd_no, cmd)
+                return
+        else:
+            raise IOError(f"Failed to send command #{cmd_no}: {cmd}.") from err
+
+    def _receive(self, cmd_no: int, num_attempts=100) -> str:
+        """Low-level execution primitive. Recives a response from HPLC.
+
+        :param cmd_no: Command number
+        :param num_attempts: Number of retries to open reply file
+        :raises IOError: Could not read reply file.
+        :return: ChemStation response 
+        """
+        err = None
+        for _ in range(num_attempts):
+            time.sleep(1)
+
+            try:
+                with open(self.reply_file, "r", encoding="utf_16") as reply_file:
+                    response = reply_file.read()
+            except OSError as e:
+                err = e
+                self.logger.warning("Failed to read from reply file; trying again.")
+                continue
+
+            try:
+                first_line = response.splitlines()[0]
+                response_no = int(first_line.split()[0])
+            except IndexError as e:
+                err = e
+                self.logger.warning("Malformed response %s; trying again.", response)
+                continue
+
+            # check that response corresponds to sent command
+            if response_no == cmd_no:
+                self.logger.info("Reply: \n%s", response)
+                return response
+            else:
+                self.logger.warning(
+                    "Response #: %d != command #: %d; trying again.",
+                    response_no,
+                    cmd_no,
+                )
+                continue
+        else:
+            raise IOError(f"Failed to receive reply to command #{cmd_no}.") from err
+
+    def sleepy_send(self, cmd: Union[Command, str]):
+        self.send("Sleep 0.1")
+        self.send(cmd)
+        self.send("Sleep 0.1")
+
+    def send(self, cmd: Union[Command, str]):
+        """Sends a command to Chemstation.
+
+        :param cmd: Command to be sent to HPLC
+        """
+        if self.cmd_no == MAX_CMD_NO:
+            self.reset_cmd_counter()
+
+        cmd_to_send: str = cmd.value if isinstance(cmd, Command) else cmd
+        self.cmd_no += 1
+        self._send(cmd_to_send, self.cmd_no)
+
+    def receive(self) -> str:
+        """Returns messages received in reply file.
+
+        :return: ChemStation response 
+        """
+        return self._receive(self.cmd_no)
+
+    def reset_cmd_counter(self):
+        """Resets the command counter."""
+        self._send(Command.RESET_COUNTER_CMD.value, cmd_no=MAX_CMD_NO + 1)
+        self._receive(cmd_no=MAX_CMD_NO + 1)
+        self.cmd_no = 0
+
+        self.logger.debug("Reset command counter")
+
+    def sleep(self, seconds: int):
+        """Tells the HPLC to wait for a specified number of seconds.
+
+        :param seconds: number of seconds to wait
+        """
+        self.send(Command.SLEEP_CMD.value.format(seconds=seconds))
+        self.logger.debug("Sleep command sent.")
+
+    def standby(self):
+        """Switches all modules in standby mode. All lamps and pumps are switched off."""
+        self.send(Command.STANDBY_CMD)
+        self.logger.debug("Standby command sent.")
+
+    def preprun(self):
+        """ Prepares all modules for run. All lamps and pumps are switched on."""
+        self.send(Command.PREPRUN_CMD)
+        self.logger.debug("PrepRun command sent.")
+
+    def status(self) -> list[Union[HPLCRunningStatus, HPLCAvailStatus, HPLCErrorStatus]]:
+        """Get device status(es).
+
+        :return: list of ChemStation's current status
+        """
+        self.send(Command.GET_STATUS_CMD)
+        time.sleep(1)
+
+        try:
+            parsed_response = self.receive().splitlines()[1].split()[1:]
+        except IOError:
+            return [HPLCErrorStatus.NORESPONSE]
+        except IndexError:
+            return [HPLCErrorStatus.MALFORMED]
+        recieved_status = [str_to_status(res) for res in parsed_response]
+        self._most_recent_hplc_status = recieved_status[0]
+        return recieved_status
+
+    def stop_macro(self):
+        """Stops Macro execution. Connection will be lost."""
+        self.send(Command.STOP_MACRO_CMD)
+
+    def lamp_on(self):
+        """Turns the UV lamp on."""
+        self.send(Command.LAMP_ON_CMD)
+
+    def lamp_off(self):
+        """Turns the UV lamp off."""
+        self.send(Command.LAMP_OFF_CMD)
+
+    def pump_on(self):
+        """Turns on the pump on."""
+        self.send(Command.PUMP_ON_CMD)
+
+    def pump_off(self):
+        """Turns the pump off."""
+        self.send(Command.PUMP_OFF_CMD)

pychemstation-0.4.7.dev3/pychemstation/control/method.py

@@ -0,0 +1,232 @@
+import os
+import time
+
+from xsdata.formats.dataclass.parsers import XmlParser
+
+from ..control.table_controller import TableController, HPLCController
+from ..generated import DadMethod, PumpMethod
+from ..utils.chromatogram import TIME_FORMAT
+from ..utils.constants import METHOD_TIMETABLE
+from ..utils.macro import Command
+from ..utils.method_types import MethodTimetable, HPLCMethodParams, Param, PType, TimeTableEntry
+from ..utils.table_types import RegisterFlag, TableOperation
+
+
+class MethodController(TableController):
+    """
+    Class containing method related logic
+    """
+
+    def __init__(self, controller: HPLCController, src: str):
+        super().__init__(controller, src)
+
+    def is_loaded(self, method_name: str):
+        """Checks if a given method is already loaded into Chemstation. Method name does not need the ".M" extension.
+
+        :param method_name: a Chemstation method
+        :return: True if method is already loaded
+        """
+        self.send(Command.GET_METHOD_CMD)
+        parsed_response = self.receive().splitlines()[1].split()[1:][0]
+        return method_name in parsed_response
+
+    def switch(self, method_name: str):
+        """Allows the user to switch between pre-programmed methods. No need to append '.M'
+        to the end of the method name. For example. for the method named 'General-Poroshell.M',
+        only 'General-Poroshell' is needed.
+
+        :param method_name: any available method in Chemstation method directory
+        :raise IndexError: Response did not have expected format. Try again.
+        :raise AssertionError: The desired method is not selected. Try again.
+        """
+        self.send(Command.SWITCH_METHOD_CMD.value.format(method_dir=self.src,
+                                                         method_name=method_name))
+
+        time.sleep(2)
+        self.send(Command.GET_METHOD_CMD)
+        time.sleep(2)
+
+        # check that method switched
+        for _ in range(10):
+            try:
+                parsed_response = self.receive().splitlines()[1].split()[1:][0]
+                break
+            except IndexError:
+                continue
+
+        assert parsed_response == f"{method_name}.M", "Switching Methods failed."
+
+    def run(self, experiment_name: str):
+        """This is the preferred method to trigger a run.
+        Starts the currently selected method, storing data
+        under the <data_dir>/<experiment_name>.D folder.
+        The <experiment_name> will be appended with a timestamp in the '%Y-%m-%d-%H-%M' format.
+        Device must be ready.
+
+        :param experiment_name: Name of the experiment
+        """
+        timestamp = time.strftime(TIME_FORMAT)
+
+        self.send(Command.RUN_METHOD_CMD.value.format(data_dir=self.src,
+                                                      experiment_name=experiment_name,
+                                                      timestamp=timestamp))
+
+        folder_name = f"{experiment_name}_{timestamp}.D"
+        self.controller.data_files.append(os.path.join(self.src, folder_name))
+
+    def load(self, method_name: str):
+        """Retrieve method details of an existing method. Don't need to append ".M" to the end. This assumes the
+        organic modifier is in Channel B and that Channel A contains the aq layer. Additionally, assumes
+         only two solvents are being used.
+
+        :param method_name: name of method to load details of
+        :raises FileNotFoundError: Method does not exist
+        :return: method details
+        """
+        method_folder = f"{method_name}.M"
+        method_path = os.path.join(self.src, method_folder, "AgilentPumpDriver1.RapidControl.MethodXML.xml")
+        dad_path = os.path.join(self.src, method_folder, "Agilent1200erDadDriver1.RapidControl.MethodXML.xml")
+
+        if os.path.exists(os.path.join(self.src, f"{method_name}.M")):
+            parser = XmlParser()
+            method = parser.parse(method_path, PumpMethod)
+            dad = parser.parse(dad_path, DadMethod)
+
+            organic_modifier = None
+            aq_modifier = None
+
+            if len(method.solvent_composition.solvent_element) == 2:
+                for solvent in method.solvent_composition.solvent_element:
+                    if solvent.channel == "Channel_A":
+                        aq_modifier = solvent
+                    elif solvent.channel == "Channel_B":
+                        organic_modifier = solvent
+
+            return MethodTimetable(
+                first_row=HPLCMethodParams(
+                    organic_modifier=Param(val=organic_modifier.percentage,
+                                           chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+                                           ptype=PType.NUM),
+                    flow=Param(val=method.flow,
+                               chemstation_key=RegisterFlag.FLOW,
+                               ptype=PType.NUM),
+                    maximum_run_time=Param(val=method.stop_time,
+                                           chemstation_key=RegisterFlag.MAX_TIME,
+                                           ptype=PType.NUM),
+                    temperature=Param(val=None,
+                                      chemstation_key=[RegisterFlag.COLUMN_OVEN_TEMP1,
+                                                       RegisterFlag.COLUMN_OVEN_TEMP2],
+                                      ptype=PType.NUM),
+                    inj_vol=Param(val=None,
+                                  chemstation_key=None,
+                                  ptype=PType.NUM),
+                    equ_time=Param(val=None,
+                                   chemstation_key=None,
+                                   ptype=PType.NUM)),
+                subsequent_rows=[
+                    TimeTableEntry(
+                        start_time=tte.time,
+                        organic_modifer=tte.percent_b,
+                        flow=method.flow
+                    ) for tte in method.timetable.timetable_entry
+                ],
+                dad_wavelengthes=dad.signals.signal,
+                organic_modifier=organic_modifier,
+                modifier_a=aq_modifier
+            )
+        else:
+            raise FileNotFoundError
+
+    def edit(self, updated_method: MethodTimetable):
+        """Updated the currently loaded method in ChemStation with provided values.
+
+        :param updated_method: the method with updated values, to be sent to Chemstation to modify the currently loaded method.
+        """
+        initial_organic_modifier: Param = updated_method.first_row.organic_modifier
+        max_time: Param = updated_method.first_row.maximum_run_time
+        temp: Param = updated_method.first_row.temperature
+        injvol: Param = updated_method.first_row.inj_vol
+        equalib_time: Param = updated_method.first_row.equ_time
+        flow: Param = updated_method.first_row.flow
+
+        # Method settings required for all runs
+        self.send(TableOperation.DELETE_TABLE.value.format(register=METHOD_TIMETABLE.register,
+                                                           table_name=METHOD_TIMETABLE.name, ))
+        self._update_param(initial_organic_modifier)
+        self._update_param(flow)
+        self._update_param(Param(val="Set",
+                                 chemstation_key=RegisterFlag.STOPTIME_MODE,
+                                 ptype=PType.STR))
+        self._update_param(max_time)
+        self._update_param(Param(val="Off",
+                                 chemstation_key=RegisterFlag.POSTIME_MODE,
+                                 ptype=PType.STR))
+
+        self.send("DownloadRCMethod PMP1")
+
+        self._update_method_timetable(updated_method.subsequent_rows)
+
+    def _update_method_timetable(self, timetable_rows: list[TimeTableEntry]):
+        self.sleepy_send('Local Rows')
+        self._get_table_rows(METHOD_TIMETABLE)
+
+        self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+        res = self._get_table_rows(METHOD_TIMETABLE)
+        while "ERROR" not in res:
+            self.sleepy_send('DelTab RCPMP1Method[1], "Timetable"')
+            res = self._get_table_rows(METHOD_TIMETABLE)
+
+        self.sleepy_send('NewTab RCPMP1Method[1], "Timetable"')
+        self._get_table_rows(METHOD_TIMETABLE)
+
+        for i, row in enumerate(timetable_rows):
+            if i == 0:
+                self.send('Sleep 1')
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self.send('Sleep 1')
+
+                self.sleepy_send('NewColText RCPMP1Method[1], "Timetable", "Function", "SolventComposition"')
+                self.sleepy_send(f'NewColVal RCPMP1Method[1], "Timetable", "Time", {row.start_time}')
+                self.sleepy_send(
+                    f'NewColVal RCPMP1Method[1], "Timetable", "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
+
+                self.send('Sleep 1')
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send('Sleep 1')
+            else:
+                self.sleepy_send('InsTabRow RCPMP1Method[1], "Timetable"')
+                self._get_table_rows(METHOD_TIMETABLE)
+
+                self.sleepy_send(
+                    f'SetTabText RCPMP1Method[1], "Timetable", Rows, "Function", "SolventComposition"')
+                self.sleepy_send(
+                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "Time", {row.start_time}')
+                self.sleepy_send(
+                    f'SetTabVal RCPMP1Method[1], "Timetable", Rows, "SolventCompositionPumpChannel2_Percentage", {row.organic_modifer}')
+
+                self.send("Sleep 1")
+                self.sleepy_send("DownloadRCMethod PMP1")
+                self.send("Sleep 1")
+                self._get_table_rows(METHOD_TIMETABLE)
+
+    def _update_param(self, method_param: Param):
+        """Change a method parameter, changes what is visibly seen in Chemstation GUI. (changes the first row in the timetable)
+
+        :param method_param: a parameter to update for currently loaded method.
+        """
+        register = METHOD_TIMETABLE.register
+        setting_command = TableOperation.UPDATE_OBJ_HDR_VAL if method_param.ptype == PType.NUM else TableOperation.UPDATE_OBJ_HDR_TEXT
+        if isinstance(method_param.chemstation_key, list):
+            for register_flag in method_param.chemstation_key:
+                self.send(setting_command.value.format(register=register,
+                                                       register_flag=register_flag,
+                                                       val=method_param.val))
+        else:
+            self.send(setting_command.value.format(register=register,
+                                                   register_flag=method_param.chemstation_key,
+                                                   val=method_param.val))
+        time.sleep(2)
+
+    def stop(self):
+        """Stops the run. A dialog window will pop up and manual intervention may be required."""
+        self.send(Command.STOP_METHOD_CMD)