예제 #1
0
    def _build_param_dict(self):
        """
        For each parameter key, add match string, match lambda function,
        and value formatting function for set commands.
        """

        SamiProtocol._build_param_dict(self)

        configuration_string_regex = self._get_configuration_string_regex()

        # PCO2 0x04, PHSEN 0x0A
        self._param_dict.add(Pco2wParameter.SAMI_DRIVER_VERSION,
                             configuration_string_regex,
                             lambda match: int(match.group(6), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x04,
                             visibility=ParameterDictVisibility.READ_ONLY,
                             display_name='Sami Driver Version')

        self._param_dict.add(Pco2wParameter.PUMP_PULSE,
                             configuration_string_regex,
                             lambda match: int(match.group(21), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x10,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Pulse Duration')

        self._param_dict.add(Pco2wParameter.PUMP_DURATION,
                             configuration_string_regex,
                             lambda match: int(match.group(22), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x20,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Measurement Duration')

        self._param_dict.add(Pco2wParameter.SAMPLES_PER_MEASUREMENT,
                             configuration_string_regex,
                             lambda match: int(match.group(23), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0xFF,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Samples Per Measurement')

        self._param_dict.add(Pco2wParameter.CYCLES_BETWEEN_BLANKS,
                             configuration_string_regex,
                             lambda match: int(match.group(24), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x54,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Cycles Between Blanks')

        self._param_dict.add(Pco2wParameter.NUMBER_REAGENT_CYCLES,
                             configuration_string_regex,
                             lambda match: int(match.group(25), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x18,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Reagent Cycles')

        self._param_dict.add(Pco2wParameter.NUMBER_BLANK_CYCLES,
                             configuration_string_regex,
                             lambda match: int(match.group(26), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x1C,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Blank Cycles')

        self._param_dict.add(Pco2wParameter.FLUSH_PUMP_INTERVAL,
                             configuration_string_regex,
                             lambda match: int(match.group(27), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x01,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Flush Pump Interval')

        self._param_dict.add(Pco2wParameter.BIT_SWITCHES,
                             configuration_string_regex,
                             lambda match: int(match.group(28), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x00,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Bit Switches')

        self._param_dict.add(Pco2wParameter.NUMBER_EXTRA_PUMP_CYCLES,
                             configuration_string_regex,
                             lambda match: int(match.group(29), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x38,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Extra Pump Cycles')

        self._param_dict.add(Pco2wParameter.PUMP_100ML_CYCLES,
                             r'Pump 100ml cycles = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x1,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump 100ml Cycles')

        self._param_dict.add(Pco2wParameter.REAGENT_FLUSH_DURATION,
                             r'Reagent flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Reagent Flush Duration')

        self._param_dict.add(Pco2wParameter.DEIONIZED_WATER_FLUSH_DURATION,
                             r'Deionized water flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Deionized Water Flush Duration')
예제 #2
0
    def _build_param_dict(self):
        """
        For each parameter key, add match string, match lambda function,
        and value formatting function for set commands.
        """

        SamiProtocol._build_param_dict(self)

        configuration_string_regex = self._get_configuration_string_regex()

        # PCO2 0x04, PHSEN 0x0A
        self._param_dict.add(Pco2wParameter.SAMI_DRIVER_VERSION, configuration_string_regex,
                             lambda match: int(match.group(6), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x04,
                             visibility=ParameterDictVisibility.IMMUTABLE,
                             display_name='Sami Driver Version',
                             description='SAMI driver version: (04 = CO2 Ave+)')

        self._param_dict.add(Pco2wParameter.PUMP_PULSE, configuration_string_regex,
                             lambda match: int(match.group(21), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x10,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Pulse Duration',
                             description='(0-255)',
                             units='1/16 ' + Units.SECOND)

        self._param_dict.add(Pco2wParameter.PUMP_DURATION, configuration_string_regex,
                             lambda match: int(match.group(22), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x20,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Measurement Duration',
                             description='(0-255)',
                             units='1/16 ' + Units.SECOND)

        self._param_dict.add(Pco2wParameter.SAMPLES_PER_MEASUREMENT, configuration_string_regex,
                             lambda match: int(match.group(23), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0xFF,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Samples Per Measurement',
                             description='Number of samples per measurement (0-255)')

        self._param_dict.add(Pco2wParameter.CYCLES_BETWEEN_BLANKS, configuration_string_regex,
                             lambda match: int(match.group(24), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x54,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Cycles Between Blanks',
                             description='Number of cycles between blanks (0-255)')

        self._param_dict.add(Pco2wParameter.NUMBER_REAGENT_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(25), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x18,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Reagent Cycles',
                             description='(0-255)')

        self._param_dict.add(Pco2wParameter.NUMBER_BLANK_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(26), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x1C,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Blank Cycles',
                             description='(0-255)')

        self._param_dict.add(Pco2wParameter.FLUSH_PUMP_INTERVAL, configuration_string_regex,
                             lambda match: int(match.group(27), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x01,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Flush Pump Interval',
                             description='(0-255)',
                             units=Units.SECOND)

        self._param_dict.add(Pco2wParameter.PUMP_SETTINGS, configuration_string_regex,
                             lambda match: int(match.group(28), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x00,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Settings',
                             description='Bit switches, where bit 0 = Don\'t start with blank flush,'
                                         ' bit 1 = measure after each pump pulse, Bits 2-7 = Unassigned, set to 0.')

        self._param_dict.add(Pco2wParameter.NUMBER_EXTRA_PUMP_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(29), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x38,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Extra Pump Cycles',
                             description='(0-255)')

        self._param_dict.add(Pco2wParameter.PUMP_100ML_CYCLES, r'Pump 100ml cycles = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x1,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump 100ml Cycles',
                             description='Number of pump cycles when executing pump (0-255)')

        self._param_dict.add(Pco2wParameter.REAGENT_FLUSH_DURATION, r'Reagent flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Reagent Flush Duration',
                             description='Set duration of reagent flush when executing pump (0-255)',
                             units='1/8 ' + Units.SECOND)

        self._param_dict.add(Pco2wParameter.DEIONIZED_WATER_FLUSH_DURATION,
                             r'Deionized water flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             range=(0, 0xFF),
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Deionized Water Flush Duration',
                             description='Set duration of deionized water flush when executing pump (0-255)',
                             units='1/8 ' + Units.SECOND)
예제 #3
0
    def _build_param_dict(self):
        """
        For each parameter key, add match string, match lambda function,
        and value formatting function for set commands.
        """

        SamiProtocol._build_param_dict(self)

        configuration_string_regex = self._get_configuration_string_regex()

        # PCO2 0x04, PHSEN 0x0A
        self._param_dict.add(Pco2wParameter.SAMI_DRIVER_VERSION, configuration_string_regex,
                             lambda match: int(match.group(6), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x04,
                             visibility=ParameterDictVisibility.READ_ONLY,
                             display_name='Sami Driver Version',
                             description='SAMI driver version: (04 = CO2 Ave+)')

        self._param_dict.add(Pco2wParameter.PUMP_PULSE, configuration_string_regex,
                             lambda match: int(match.group(21), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x10,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Pulse Duration',
                             description='',
                             units='16 ' + Units.HERTZ)

        self._param_dict.add(Pco2wParameter.PUMP_DURATION, configuration_string_regex,
                             lambda match: int(match.group(22), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x20,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Measurement Duration',
                             description='',
                             units='16 ' + Units.HERTZ)

        self._param_dict.add(Pco2wParameter.SAMPLES_PER_MEASUREMENT, configuration_string_regex,
                             lambda match: int(match.group(23), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0xFF,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Samples Per Measurement',
                             description='Number of samples per measurement.')

        self._param_dict.add(Pco2wParameter.CYCLES_BETWEEN_BLANKS, configuration_string_regex,
                             lambda match: int(match.group(24), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x54,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Cycles Between Blanks',
                             description='Number of cycles between blanks.')

        self._param_dict.add(Pco2wParameter.NUMBER_REAGENT_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(25), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x18,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Reagent Cycles',
                             description='')

        self._param_dict.add(Pco2wParameter.NUMBER_BLANK_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(26), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x1C,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Blank Cycles',
                             description='')

        self._param_dict.add(Pco2wParameter.FLUSH_PUMP_INTERVAL, configuration_string_regex,
                             lambda match: int(match.group(27), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x01,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Flush Pump Interval',
                             description='',
                             units=Units.SECOND)

        self._param_dict.add(Pco2wParameter.PUMP_SETTINGS, configuration_string_regex,
                             lambda match: int(match.group(28), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x00,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Settings',
                             description='Bit switches, where bit 0 = Don\'t start with blank flush,'
                                         ' bit 1 = measure after each pump pulse, Bits 2-7 = Unassigned, set to 0.')

        self._param_dict.add(Pco2wParameter.NUMBER_EXTRA_PUMP_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(29), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x38,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Extra Pump Cycles',
                             description='')

        self._param_dict.add(Pco2wParameter.PUMP_100ML_CYCLES, r'Pump 100ml cycles = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x1,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump 100ml Cycles',
                             description='Number of pump cycles when executing pump.')

        self._param_dict.add(Pco2wParameter.REAGENT_FLUSH_DURATION, r'Reagent flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Reagent Flush Duration',
                             description='Set duration of reagent flush when executing pump.',
                             units='8 ' + Units.HERTZ)

        self._param_dict.add(Pco2wParameter.DEIONIZED_WATER_FLUSH_DURATION,
                             r'Deionized water flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Deionized Water Flush Duration',
                             description='Set duration of deionized water flush when executing pump.',
                             units='8 ' + Units.HERTZ)
예제 #4
0
    def _build_param_dict(self):
        """
        For each parameter key, add match string, match lambda function,
        and value formatting function for set commands.
        """

        SamiProtocol._build_param_dict(self)

        configuration_string_regex = self._get_configuration_string_regex()

        # PCO2 0x04, PHSEN 0x0A
        self._param_dict.add(Pco2wParameter.SAMI_DRIVER_VERSION, configuration_string_regex,
                             lambda match: int(match.group(6), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x04,
                             visibility=ParameterDictVisibility.READ_ONLY,
                             display_name='Sami Driver Version')

        self._param_dict.add(Pco2wParameter.PUMP_PULSE, configuration_string_regex,
                             lambda match: int(match.group(21), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x10,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Pulse Duration')

        self._param_dict.add(Pco2wParameter.PUMP_DURATION, configuration_string_regex,
                             lambda match: int(match.group(22), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x20,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump Measurement Duration')

        self._param_dict.add(Pco2wParameter.SAMPLES_PER_MEASUREMENT, configuration_string_regex,
                             lambda match: int(match.group(23), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0xFF,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Samples Per Measurement')

        self._param_dict.add(Pco2wParameter.CYCLES_BETWEEN_BLANKS, configuration_string_regex,
                             lambda match: int(match.group(24), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x54,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Cycles Between Blanks')

        self._param_dict.add(Pco2wParameter.NUMBER_REAGENT_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(25), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x18,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Reagent Cycles')

        self._param_dict.add(Pco2wParameter.NUMBER_BLANK_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(26), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x1C,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Blank Cycles')

        self._param_dict.add(Pco2wParameter.FLUSH_PUMP_INTERVAL, configuration_string_regex,
                             lambda match: int(match.group(27), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x01,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Flush Pump Interval')

        self._param_dict.add(Pco2wParameter.BIT_SWITCHES, configuration_string_regex,
                             lambda match: int(match.group(28), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x00,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Bit Switches')

        self._param_dict.add(Pco2wParameter.NUMBER_EXTRA_PUMP_CYCLES, configuration_string_regex,
                             lambda match: int(match.group(29), 16),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=True,
                             default_value=0x38,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Number of Extra Pump Cycles')

        self._param_dict.add(Pco2wParameter.PUMP_100ML_CYCLES, r'Pump 100ml cycles = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x1,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Pump 100ml Cycles')

        self._param_dict.add(Pco2wParameter.REAGENT_FLUSH_DURATION, r'Reagent flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Reagent Flush Duration')

        self._param_dict.add(Pco2wParameter.DEIONIZED_WATER_FLUSH_DURATION,
                             r'Deionized water flush duration = ([0-9]+)',
                             lambda match: match.group(1),
                             lambda x: self._int_to_hexstring(x, 2),
                             type=ParameterDictType.INT,
                             startup_param=True,
                             direct_access=False,
                             default_value=0x8,
                             visibility=ParameterDictVisibility.READ_WRITE,
                             display_name='Deionized Water Flush Duration')