pychemstation 0.10.11__py3-none-any.whl → 0.10.12__py3-none-any.whl

pychemstation/control/controllers/comm.py

@@ -54,7 +54,7 @@ class CommunicationController(ABCCommunicationController):
         raise RuntimeError("Failed to get number.")
 
     def get_text_val(self, cmd: str) -> str:
-        tries = 10
+        tries = 5
         for _ in range(tries):
             self.send(Command.GET_TEXT_VAL_CMD.value.format(cmd=cmd))
             res = self.receive()

pychemstation/control/controllers/data_aq/method.py

@@ -5,12 +5,16 @@ import time
 import warnings
 from typing import Dict, List, Optional, Union, Tuple
 
-from result import Err, Ok, Result
+from result import Err, Result, Ok
 
-from pychemstation.analysis.chromatogram import (
+from ..devices.column import ColumnController
+from ..devices.dad import DADController
+from ..devices.pump import PumpController
+from ..devices.sample_info import SampleInfo
+from ....analysis.chromatogram import (
     TIME_FORMAT,
-    AgilentChannelChromatogramData,
     AgilentHPLCChromatogram,
+    AgilentChannelChromatogramData,
 )
 
 from ....analysis.process_report import AgilentReport, ReportType
@@ -20,12 +24,13 @@ from ....utils.macro import Command
 from ....utils.method_types import (
     HPLCMethodParams,
     MethodDetails,
+    TimeTableEntry,
     Param,
     PType,
-    TimeTableEntry,
 )
-from ....utils.table_types import RegisterFlag, T, Table, TableOperation
+from ....utils.table_types import RegisterFlag, T, Table
 from ..devices.injector import InjectorController
+from ....utils.tray_types import Tray
 
 
 class MethodController(RunController):
@@ -38,9 +43,17 @@ class MethodController(RunController):
         data_dirs: Optional[List[str]],
         table: Table,
         offline: bool,
-        injector_controller: InjectorController,
+        injector: InjectorController,
+        pump: PumpController,
+        dad: DADController,
+        column: ColumnController,
+        sample_info: SampleInfo,
     ):
-        self.injector_controller = injector_controller
+        self.injector = injector
+        self.pump = pump
+        self.dad = dad
+        self.column = column
+        self.sample_info = sample_info
         self.data_files: List[str] = []
         super().__init__(
             controller=controller,
@@ -50,6 +63,9 @@ class MethodController(RunController):
             offline=offline,
         )
 
+    def get_sample_location(self) -> Tray:
+        return self.sample_info.get_location()
+
     def get_current_method_name(self) -> str:
         self.sleepy_send(Command.GET_METHOD_CMD)
         res = self.receive()
@@ -60,18 +76,8 @@ class MethodController(RunController):
     def get_method_params(self) -> HPLCMethodParams:
         if self.controller:
             return HPLCMethodParams(
-                organic_modifier=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        register=self.table_locator.register,
-                        register_flag=RegisterFlag.SOLVENT_B_COMPOSITION,
-                    )
-                ),
-                flow=self.controller.get_num_val(
-                    cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                        register=self.table_locator.register,
-                        register_flag=RegisterFlag.FLOW,
-                    )
-                ),
+                organic_modifier=self.get_om(),
+                flow=self.get_flow(),
             )
         raise ValueError("Communication controller is offline!")
 
@@ -135,26 +141,6 @@ class MethodController(RunController):
         method_name = res.ok_value.string_response
         return method_name
 
-    def get_post_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.POST_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
-    def get_stop_time(self) -> Union[int, float]:
-        if self.controller:
-            return self.controller.get_num_val(
-                cmd=TableOperation.GET_OBJ_HDR_VAL.value.format(
-                    register=self.table_locator.register,
-                    register_flag=RegisterFlag.MAX_TIME,
-                )
-            )
-        raise ValueError("Communication controller is not online!")
-
     def get_total_runtime(self) -> Union[int, float]:
         """Returns total method runtime in minutes."""
         return self.get_post_time() + self.get_stop_time()
@@ -214,20 +200,14 @@ class MethodController(RunController):
         self.edit_method_timetable(updated_method.timetable)
 
         if save:
-            self.send(
-                Command.SAVE_METHOD_CMD.value.format(
-                    commit_msg=f"saved method at {str(time.time())}"
-                )
-            )
+            self.save_method()
 
-    def edit_initial_om(self, new_om: Union[int, float]):
-        self._validate_organic_modifier(new_om)
-        initial_organic_modifier: Param = Param(
-            val=new_om,
-            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
-            ptype=PType.NUM,
+    def save_method(self):
+        self.send(
+            Command.SAVE_METHOD_CMD.value.format(
+                commit_msg=f"saved method at {str(time.time())}"
+            )
         )
-        self._update_param(initial_organic_modifier)
 
     def _validate_organic_modifier(self, new_om):
         if not (isinstance(new_om, int) or isinstance(new_om, float)):
@@ -237,13 +217,6 @@ class MethodController(RunController):
         if new_om > 100:
             raise ValueError("Organic modifer must be less than 100.")
 
-    def edit_flow(self, new_flow: Union[int, float]):
-        self._validate_flow(new_flow)
-        flow: Param = Param(
-            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
-        )
-        self._update_param(flow)
-
     def _validate_flow(self, new_flow):
         if not (isinstance(new_flow, int) or isinstance(new_flow, float)):
             raise ValueError("Flow must be int or float")
@@ -252,38 +225,12 @@ class MethodController(RunController):
         if new_flow >= 5.0:
             raise ValueError("Flow must be less than 5.0")
 
-    def edit_stop_time(self, new_stop_time: Union[int, float]):
-        self.validate_stop_time(new_stop_time)
-        stop_time: Param = Param(
-            val=new_stop_time,
-            chemstation_key=RegisterFlag.MAX_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(
-                val="Set", chemstation_key=RegisterFlag.STOPTIME_MODE, ptype=PType.STR
-            )
-        )
-        self._update_param(stop_time)
-
     def validate_stop_time(self, new_stop_time):
         if not (isinstance(new_stop_time, int) or isinstance(new_stop_time, float)):
             raise ValueError("Stop time must be int or float")
         if new_stop_time < 0:
             raise ValueError("Stop time must be positive")
 
-    def edit_post_time(self, new_post_time: Union[int, float]):
-        self.validate_post_time(new_post_time)
-        post_time: Param = Param(
-            val=new_post_time,
-            chemstation_key=RegisterFlag.POST_TIME,
-            ptype=PType.NUM,
-        )
-        self._update_param(
-            Param(val="Set", chemstation_key=RegisterFlag.POSTIME_MODE, ptype=PType.STR)
-        )
-        self._update_param(post_time)
-
     def validate_post_time(self, new_post_time):
         if not (isinstance(new_post_time, int) or isinstance(new_post_time, float)):
             raise ValueError("Post time must be int or float")
@@ -298,59 +245,14 @@ class MethodController(RunController):
         new_post_time: Union[int, float] | None,
     ):
         self.delete_table()
-        self.edit_initial_om(new_initial_om)
+        self._validate_flow(new_flow)
+        self.validate_post_time(new_post_time)
+        self._validate_organic_modifier(new_initial_om)
+        self.validate_stop_time(new_stop_time)
         self.edit_flow(new_flow)
-        if new_stop_time:
-            self.edit_stop_time(new_stop_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.STOPTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-        if new_post_time:
-            self.edit_post_time(new_post_time)
-        else:
-            self._update_param(
-                Param(
-                    val="Off",
-                    chemstation_key=RegisterFlag.POSTIME_MODE,
-                    ptype=PType.STR,
-                )
-            )
-
-    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 = self.table_locator.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.sleepy_send(
-                    setting_command.value.format(
-                        register=register,
-                        register_flag=register_flag,
-                        val=method_param.val,
-                    )
-                )
-        else:
-            self.sleepy_send(
-                setting_command.value.format(
-                    register=register,
-                    register_flag=method_param.chemstation_key,
-                    val=method_param.val,
-                )
-            )
-        self.download()
+        self.edit_initial_om(new_initial_om)
+        self.edit_stop_time(new_stop_time)
+        self.edit_post_time(new_post_time)
 
     def download(self):
         self.sleepy_send("DownloadRCMethod PMP1")
@@ -585,3 +487,77 @@ class MethodController(RunController):
                     Row {i + 1} ({timetable[i].start_time}) has a smaller or equal starttime than row {i} ({start_time})"""
                 )
             self._validate_row(row)
+
+    def get_om(self):
+        return self._read_num_param(RegisterFlag.SOLVENT_B_COMPOSITION)
+
+    def get_flow(self):
+        return self._read_num_param(RegisterFlag.FLOW)
+
+    def get_post_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.POST_TIME)
+
+    def get_stop_time(self) -> Union[int, float]:
+        return self._read_num_param(RegisterFlag.MAX_TIME)
+
+    def edit_post_time(self, new_post_time: Optional[int | float]):
+        if new_post_time:
+            post_time: Param = Param(
+                val=new_post_time,
+                chemstation_key=RegisterFlag.POST_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(post_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.POSTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_stop_time(self, new_stop_time: Optional[int | float]):
+        if new_stop_time:
+            stop_time: Param = Param(
+                val=new_stop_time,
+                chemstation_key=RegisterFlag.MAX_TIME,
+                ptype=PType.NUM,
+            )
+            self._update_param(
+                Param(
+                    val="Set",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+            self._update_param(stop_time)
+        else:
+            self._update_param(
+                Param(
+                    val="Off",
+                    chemstation_key=RegisterFlag.STOPTIME_MODE,
+                    ptype=PType.STR,
+                )
+            )
+
+    def edit_flow(self, new_flow: Union[int, float]):
+        flow: Param = Param(
+            val=new_flow, chemstation_key=RegisterFlag.FLOW, ptype=PType.NUM
+        )
+        self._update_param(flow)
+
+    def edit_initial_om(self, new_om: Union[int, float]):
+        initial_organic_modifier: Param = Param(
+            val=new_om,
+            chemstation_key=RegisterFlag.SOLVENT_B_COMPOSITION,
+            ptype=PType.NUM,
+        )
+        self._update_param(initial_organic_modifier)

pychemstation/control/controllers/data_aq/sequence.py

@@ -89,18 +89,17 @@ class SequenceController(RunController):
             raise ValueError("Expected vial location, is empty.")
 
     def get_row(self, row: int) -> SequenceEntry:
-        sample_name = self.get_text(row, RegisterFlag.NAME)
-        vial_location = self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
-        data_file = self.get_text(row, RegisterFlag.DATA_FILE)
-        method = self.get_text(row, RegisterFlag.METHOD)
-        num_inj = self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
-        inj_vol = self.try_float(self.get_text(row, RegisterFlag.INJ_VOL))
-        inj_source = InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
-        sample_type = SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
-        vial_enum = self.try_vial_location(vial_location)
+        sample_name = self.get_sample_name(row)
+        vial_location = self.get_vial_location(row)
+        data_file = self.get_data_file(row)
+        method = self.get_method(row)
+        num_inj = self.get_num_inj(row)
+        inj_vol = self.get_inj_vol(row)
+        inj_source = self.get_inj_source(row)
+        sample_type = self.get_sample_type(row)
         return SequenceEntry(
             sample_name=sample_name,
-            vial_location=vial_enum,
+            vial_location=vial_location,
             method=None if len(method) == 0 else method,
             num_inj=num_inj,
             inj_vol=inj_vol,
@@ -109,6 +108,32 @@ class SequenceController(RunController):
             data_file=data_file,
         )
 
+    def get_sample_type(self, row):
+        return SampleType(self.get_num(row, RegisterFlag.SAMPLE_TYPE))
+
+    def get_inj_source(self, row):
+        return InjectionSource(self.get_text(row, RegisterFlag.INJ_SOR))
+
+    def get_inj_vol(self, row):
+        return self.try_float(self.get_text(row, RegisterFlag.INJ_VOL))
+
+    def get_num_inj(self, row):
+        return self.try_int(self.get_num(row, RegisterFlag.NUM_INJ))
+
+    def get_method(self, row):
+        return self.get_text(row, RegisterFlag.METHOD)
+
+    def get_data_file(self, row):
+        return self.get_text(row, RegisterFlag.DATA_FILE)
+
+    def get_vial_location(self, row) -> Tray:
+        return self.try_vial_location(
+            self.try_int(self.get_num(row, RegisterFlag.VIAL_LOCATION))
+        )
+
+    def get_sample_name(self, row):
+        return self.get_text(row, RegisterFlag.NAME)
+
     def switch(self, seq_name: str):
         """
         Switch to the specified sequence. The sequence name does not need the '.S' extension.
@@ -145,12 +170,12 @@ class SequenceController(RunController):
             self.send(Command.SAVE_SEQUENCE_CMD)
         for i in range(int(wanted_row_num)):
             self.add_row()
-            self.save()
+            self.download()
         self.send(Command.SWITCH_SEQUENCE_CMD)
         for i, row in enumerate(sequence_table.rows):
             self._edit_row(row=row, row_num=i + 1)
             self.sleep(1)
-        self.save()
+        self.download()
         self.send(Command.SWITCH_SEQUENCE_CMD)
 
     def _edit_row(self, row: SequenceEntry, row_num: int):
@@ -163,7 +188,7 @@ class SequenceController(RunController):
         num_rows = self.get_row_count_safely()
         while num_rows < row_num:
             self.add_row()
-            self.save()
+            self.download()
             num_rows = self.get_row_count_safely()
         if row.vial_location:
             self.edit_vial_location(row.vial_location, row_num, save=False)
@@ -181,7 +206,7 @@ class SequenceController(RunController):
             self.edit_data_file(row.data_file, row_num, save=False)
         if row.sample_type:
             self.edit_sample_type(row.sample_type, row_num, save=False)
-        self.save()
+        self.download()
 
     def edit_sample_type(
         self, sample_type: SampleType, row_num: int, save: bool = True
@@ -194,17 +219,17 @@ class SequenceController(RunController):
             val=sample_type.value,
         )
         if save:
-            self.save()
+            self.download()
 
     def edit_data_file(self, data_file: str, row_num: int, save: bool = True):
         self._edit_row_text(row=row_num, col_name=RegisterFlag.DATA_FILE, val=data_file)
         if save:
-            self.save()
+            self.download()
 
     def edit_sample_name(self, sample_name: str, row_num: int, save: bool = True):
         self._edit_row_text(row=row_num, col_name=RegisterFlag.NAME, val=sample_name)
         if save:
-            self.save()
+            self.download()
 
     def edit_injection_source(
         self, inj_source: InjectionSource, row_num: int, save: bool = True
@@ -215,7 +240,7 @@ class SequenceController(RunController):
             row=row_num, col_name=RegisterFlag.INJ_SOR, val=inj_source.value
         )
         if save:
-            self.save()
+            self.download()
 
     def edit_injection_volume(
         self, inj_vol: Union[int, float], row_num: int, save: bool = True
@@ -224,12 +249,12 @@ class SequenceController(RunController):
             row=row_num, col_name=RegisterFlag.INJ_VOL, val=str(inj_vol)
         )
         if save:
-            self.save()
+            self.download()
 
     def edit_num_injections(self, num_inj: int, row_num: int, save: bool = True):
         self._edit_row_num(row=row_num, col_name=RegisterFlag.NUM_INJ, val=num_inj)
         if save:
-            self.save()
+            self.download()
 
     def edit_method_name(
         self, method: str, row_num: int, save: bool = True, override_check: bool = False
@@ -244,7 +269,7 @@ class SequenceController(RunController):
             )
         self._edit_row_text(row=row_num, col_name=RegisterFlag.METHOD, val=method)
         if save:
-            self.save()
+            self.download()
 
     def edit_vial_location(self, loc: Tray, row_num: int, save: bool = True):
         loc_num = -1
@@ -270,7 +295,7 @@ class SequenceController(RunController):
                 self._edit_row(previous_contents, num_rows)
                 self.move_row(int(num_rows), row_num)
                 self.delete_row(row_num + 1)
-                self.save()
+                self.download()
             else:
                 raise ValueError(
                     "`loc` should be of type `VialBar`, `FiftyFourVialPlate`"
@@ -288,9 +313,9 @@ class SequenceController(RunController):
                 row=row_num, col_name=RegisterFlag.VIAL_LOCATION, val=loc_num
             )
         if save:
-            self.save()
+            self.download()
 
-    def save(self):
+    def download(self):
         self.send(Command.SAVE_SEQUENCE_CMD)
 
     def run(self, stall_while_running: bool = True):

pychemstation/control/controllers/devices/column.py

@@ -0,0 +1,61 @@
+from typing import List, Dict
+
+from ....control.controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
+from ....utils.macro import Command
+from ....utils.method_types import Param, PType
+from ....utils.table_types import Device, Table, RegisterFlag
+
+
+class ColumnController(DeviceController):
+    def __init__(
+        self, controller: CommunicationController, table: Table | Device, offline: bool
+    ):
+        super().__init__(controller, table, offline)
+        if not self.offline:
+            self.display_to_internal: Dict[str, str] = {
+                display_name: real_name
+                for display_name, real_name in zip(
+                    self.check_available_column_positions(),
+                    self._internal_column_positions(),
+                )
+            }
+            self.internal_to_display: Dict[str, str] = dict(
+                map(reversed, self.display_to_internal.items())  # type: ignore
+            )
+
+    def check_column_position(self):
+        return self.internal_to_display[
+            self._read_str_param(register_flag=RegisterFlag.COLUMN_POSITION)
+        ]
+
+    def _internal_column_positions(self) -> List[str]:
+        return self._read_str_param(
+            register_flag=RegisterFlag.AVAIL_COLUMN_POSITIONS
+        ).split("|")
+
+    def check_available_column_positions(self) -> List[str]:
+        return self._read_str_param(
+            register_flag=RegisterFlag.AVAIL_COLUMN_DISPLAY_VALUES
+        ).split("|")
+
+    def change_column_position(self, column: str):
+        if column not in self.display_to_internal.keys():
+            raise ValueError(f"Please use one of: {self.display_to_internal.keys()}")
+        self._update_param(
+            Param(
+                ptype=PType.STR,
+                chemstation_key=RegisterFlag.COLUMN_POSITION,
+                val=self.display_to_internal[column],
+            ),
+        )
+
+    def turn_off(self):
+        self.sleepy_send(Command.COLUMN_OFF_CMD)
+        pass
+
+    def turn_on(self):
+        self.sleepy_send(Command.COLUMN_ON_CMD)
+
+    def download(self):
+        self.sleepy_send("DownloadRCMethod THM1")

pychemstation/control/controllers/devices/dad.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import warnings
+
+from ...controllers import CommunicationController
+from ....utils.abc_tables.device import DeviceController
+from ....utils.device_types import DADChannels, DADChannel
+from ....utils.macro import Command
+from ....utils.method_types import Param, PType
+from ....utils.table_types import RegisterFlag, Table, Device
+
+
+class DADController(DeviceController):
+    def __init__(
+        self, controller: CommunicationController, table: Table | Device, offline: bool
+    ):
+        super().__init__(controller, table, offline)
+
+    def download(self):
+        self.sleepy_send("DownloadRCMethod DAD1")
+
+    def turn_off(self):
+        self.send(Command.LAMP_OFF_CMD)
+
+    def turn_on(self):
+        self.send(Command.LAMP_ON_CMD)
+
+    def load_wavelengths(self) -> DADChannels:
+        return DADChannels(
+            A=self._read_num_param(RegisterFlag.SIGNAL_A),
+            A_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_A_USED)),
+            B=self._read_num_param(RegisterFlag.SIGNAL_B),
+            B_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_B_USED)),
+            C=self._read_num_param(RegisterFlag.SIGNAL_C),
+            C_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_C_USED)),
+            D=self._read_num_param(RegisterFlag.SIGNAL_D),
+            D_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_D_USED)),
+            E=self._read_num_param(RegisterFlag.SIGNAL_E),
+            E_ON=bool(self._read_num_param(RegisterFlag.SIGNAL_E_USED)),
+        )
+
+    def edit_wavelength(self, signal: int, wavelength: DADChannel):
+        warnings.warn("You may need to check that the wavelength is calibrated.")
+        register = RegisterFlag.SIGNAL_A
+        match wavelength:
+            case DADChannel.A:
+                register = RegisterFlag.SIGNAL_A
+            case DADChannel.B:
+                register = RegisterFlag.SIGNAL_B
+            case DADChannel.C:
+                register = RegisterFlag.SIGNAL_C
+            case DADChannel.D:
+                register = RegisterFlag.SIGNAL_D
+            case DADChannel.E:
+                register = RegisterFlag.SIGNAL_E
+        self._update_param(
+            Param(
+                ptype=PType.NUM,
+                val=signal,
+                chemstation_key=register,
+            )
+        )
+        self.download()
+
+    def set_wavelength_usage(self, wavelength: DADChannel, on: bool):
+        register = RegisterFlag.SIGNAL_A_USED
+        match wavelength:
+            case DADChannel.A:
+                register = RegisterFlag.SIGNAL_A_USED
+            case DADChannel.B:
+                register = RegisterFlag.SIGNAL_B_USED
+            case DADChannel.C:
+                register = RegisterFlag.SIGNAL_C_USED
+            case DADChannel.D:
+                register = RegisterFlag.SIGNAL_D_USED
+            case DADChannel.E:
+                register = RegisterFlag.SIGNAL_E_USED
+        self._update_param(
+            Param(
+                ptype=PType.NUM,
+                val=int(on),
+                chemstation_key=register,
+            )
+        )
+        self.download()

pychemstation/control/controllers/devices/injector.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import warnings
+
 from ....control.controllers import CommunicationController
 from ....utils.abc_tables.device import DeviceController
 from ....utils.injector_types import (
@@ -15,6 +17,7 @@ from ....utils.injector_types import (
     DrawDefaultVolume,
     DrawDefaultLocation,
 )
+from ....utils.method_types import Param, PType
 from ....utils.table_types import RegisterFlag, Table
 from ....utils.tray_types import Tray, FiftyFourVialPlate, VialBar, LocationPlus
 
@@ -25,6 +28,21 @@ class InjectorController(DeviceController):
     ):
         super().__init__(controller, table, offline)
 
+    def turn_off(self):
+        warnings.warn("Injector has no on/off state.")
+
+    def turn_on(self):
+        warnings.warn("Injector has no on/off state.")
+
+    def change_injection_volume(self, new_injection_volume: float):
+        self._update_param(
+            param=Param(
+                ptype=PType.NUM,
+                val=new_injection_volume,
+                chemstation_key=RegisterFlag.INJECTION_VOLUME,
+            )
+        )
+
     def try_vial_location(self, val: str) -> Tray:
         try:
             return FiftyFourVialPlate.from_str(val)