Upload 7 files

Aliquot_for_EasySteps_v2.txt

@@ -0,0 +1,50 @@
+Aliquot for Easy Steps v2
+=================================================
+
+https://github.com/theonetruenerd/VenusPackages/blob/main/Aliquot_for_EasySteps_v2.pkg
+
+This library adds two functions aimed at making aliquoting steps easier. The functions added are:
+
+  - :ven:func:`CalcAliquot_v2_1`
+  - :ven:func:`CalcChannelPattern`
+
+.. ven:function:: CalcAliquot_v2_1(sequence DispenseSequence, variable VolumePerWell, variable VolumePreAliquote, variable VolumePostAliquote, variable MaxVolumeTip, variable NumberOfDispense, variable NumberOfChannels, variable intNumberOfChannelsInstalled, array arrVolumeToAspirateByChannel, array arrVolumeToMixBeforeAspiration, array arrChannelPatternDispense, variable strChannelPatternAspirate)
+
+  This function calculates the important variables for performing an aliquote pipetting with Easy- or Single Steps
+
+  :params DispenseSequence: The sequence for the aliquots to be dispensed into
+  :params VolumePerWell: The volume of the aliquotes per well
+  :params VolumePreAliquote: The volume of the pre-aliquote
+  :params VolumePostAliquote: The volume of the post-aliquote
+  :params MaxVolumeTip: The maximum volume of the selected CO-RE Tip
+  :params NumberOfDispense: The number of dispense steps per aspiration
+  :params NumberOfChannels: The number of the channels to use for the process
+  :params intNumberOfChannelsInstalled: The number of channels installed in the system
+  :params arrVolumeToAspirateByChannel: An output of the array of volumes to aspirate by channel
+  :params arrVolumeToMixBeforeAspiration: An output of the array of volumes to mix before aspiration (typically used during the first aspiration only)
+  :params arrChannelPatternDispense: The output array of channel patterns for the dispense
+  :params strChannelPatternAspirate: An output string of the channel pattern to aspirate
+  :type DispenseSequence: Sequence
+  :type VolumePerWell: Variable 
+  :type VolumePreAliquote: Variable
+  :type VolumePostAliquote: Variable
+  :type MaxVolumeTip: Variable
+  :type NumberOfDispense: Variable
+  :type NumberOfChannels: Variable
+  :type intNumberOfChannelsInstalled: Variable
+  :type arrVolumeToAspirateByChannel: Array
+  :type arrVolumeToMixBeforeAspiration: Array
+  :type arrChannelPatternDispense: Array
+  :type strChannelPatternAspirate: String
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: CalcChannelPattern(variable i_int_NumberOfPositions, variable i_int_NumberOfInstalledChannels, variable o_str_ChannelPattern)
+
+  This function creats a channel pattern based on the number of desired positions and the number of installed channels.
+
+  :params i_int_NumberOfPositions: The number of positions to use, which must be less than or equal to the Number of Installed Channels
+  :params i_int_NumberOfInstalledChannels: The number of channels installed on the instrument
+  :params o_str_ChannelPattern: The output channel pattern as a string  
+  :return: None
+  :rtype: N/A

Array.txt

@@ -0,0 +1,213 @@
+Array (from HSLExtensions)
+=========================
+
+https://github.com/theonetruenerd/VenusPackages/blob/main/Array.pkg
+
+The array library from HSLExtensions adds functions to help manipulate 1-D arrays. The following functions are added:
+
+- :ven:func:`Append`
+- :ven:func:`CompareArrays`
+- :ven:func:`Concat`
+- :ven:func:`ContainsDuplicates`
+- :ven:func:`ContainsValue`
+- :ven:func:`ConvertToBooleanArray`
+- :ven:func:`ConvertToFloatArray`
+- :ven:func:`ConvertToIntegerArray`
+- :ven:func:`ConvertToStringArray`
+- :ven:func:`Copy`
+- :ven:func:`FindValue`
+- :ven:func:`InitializeAllValues`
+- :ven:func:`IsBooleanArray`
+- :ven:func:`IsEmpty`
+- :ven:func:`IsFloatArray`
+- :ven:func:`IsIntegerArray`
+- :ven:func:`IsStringArray`
+- :ven:func:`Sort`
+
+.. ven:function:: Append(array io_arrValuesA, array i_arrValuesB)
+
+  This function updates the array io_arrValuesA to add all the values from i_arrValuesB at the end of the array.
+
+  :params io_arrValuesA: The array to which the values will be added 
+  :params i_arrValuesB: The array from which the values will be added
+  :type io_arrValuesA: Array
+  :type i_arrValuesB: Array
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: CompareArrays(array i_arrExpectedValues, array i_arrActualValues, array o_arrMissingValues, array o_arrNotExpectedValues)
+
+  This function compares two arrays and outputs arrays of values which are missing from the first array but present in the second, and values which are present in the second array but not in the first.
+
+  :params i_arrExpectedValues: The first array, which the second array will be checked against, usually is the array of expected values
+  :params i_arrActualValues: The second array, which will use the first array as a template when comparing against, usually is your "actual" array
+  :params o_arrMissingValues: An output array of values which are present in the first array but not the second 
+  :params o_arrNotExpectedValues: An output array of values which are present in the second array but not the first (i.e. unexpected values in your actual data)
+  :type i_arrExpectedValues: Array
+  :type i_arrActualValues: Array
+  :type o_arrMissingValues: Array
+  :type o_arrNotExpectedValues: Array
+  :return: True if both arrays contain the same values (resulting in empty output arrays), false if arrays don't contain the same values (in which case the output arrays will have data in them)
+  :rtype: Boolean
+
+.. ven:function:: Concat(array i_arrValuesA, array i_arrValuesB)
+
+  This function appends one array to the other and then returns the concatenated array. The difference between this and the :ven:func:`Append` function is that the Append function updates an existing array, whereas this function doesn't change the existing arrays and instead returns a new array.
+
+  :params i_arrValuesA: The array to which the values will be added
+  :params i_arrValuesB: The array from which the values will be added
+  :type i_arrValuesA: Array
+  :type i_arrValuesB: Array
+  :return: A new array which is the concatenated version of the input arrays
+  :rtype: Array
+
+.. ven:function:: ContainsDuplicates(array i_arrValues)
+
+  This function checks whether the input array has multiple of the same value in it
+
+  :params i_arrValues: The array to be checked
+  :type i_arrValues: Array
+  :return: An array with all values which appear more than once in the input array
+  :rtype: Array
+
+.. ven:function:: ContainsValue(array i_arrValues, variable i_varValue)
+
+  This function determines whether a value exists in an array without returning its index
+
+  :params i_arrValues: The array to be searched
+  :params i_varValue: The value to be searched for
+  :type i_arrValues: Array
+  :type i_varValue: Variable
+  :return: True if the value is present, false otherwise
+  :rtype: Boolean
+
+.. ven:function:: ConvertToBooleanArray(array i_arrValues, variable o_blnSuccessfullyConverted)
+
+  This function converts the input array to an array with boolean values. If it is not possible to convert one or more values of the input array, the output will be false and the output array will be empty. Cannot interact with strings, will convert a non-zero int or float into a 1, and will turn a 0 float into a 0.
+
+  :params i_arrValues: The array to be converted
+  :params o_blnSuccessfullyConverted: A boolean which tells you whether the conversion was successful or not
+  :type i_arrValues: Array
+  :type o_blnSuccessfullyConverted: Boolean
+  :return: The boolean version of the input array
+  :rtype: Array
+
+.. ven:function:: ConvertToFloatArray(array i_arrValues, variable o_blnSuccessfullyConverted)
+
+  This function converts the input array to an array with float values. If it is not possible to convert one or more values of the input array, the output will be false and the output array will be empty. Cannot interact with strings, will convert any int into a float. 
+
+  :params i_arrValues: The array to be converted
+  :params o_blnSuccessfullyConverted: A boolean which tells you whether the conversion was successful or not
+  :type i_arrValues: Array
+  :type o_blnSuccessfullyConverted: Boolean
+  :return: The float version of the input array
+  :rtype: Array
+
+.. ven:function:: ConvertToIntArray(array i_arrValues, variable o_blnSuccessfullyConverted)
+
+  This function converts the input array to one with integer values. If it is not possible to convert one or more values of the input array, the output will be false and the output array will be empty. Cannot interact with strings, will round any floats to the nearest integer.
+
+  :params i_arrValues: The array to be converted
+  :params o_blnSuccessfullyConverted: A boolean which tells you whether the conversion was successful or not
+  :type i_arrValues: Array
+  :type o_blnSuccessfullyConverted: Boolean
+  :return: The integer version of the input array
+  :rtype: Array
+
+.. ven:function:: ConvertToStringArray(array i_arrValues)
+
+  This function converts the input array to one with string values. 
+
+  :params i_arrValues: The array to be converted
+  :type i_arrValues: Array
+  :return: The float version of the input array
+  :rtype: Array
+
+.. ven:function:: Copy(array i_arrValues)
+
+  This function will output an exact copy of the input array. 
+
+  :params i_arrValues: The array to be copied
+  :type i_arrValues: Array
+  :return: A copy of the input array
+  :rtype: Array
+
+.. ven:function:: FindValue(array i_arrValues, variable i_varValue)
+
+  This function will lookup the input variable within the input array and return a 1-based array of the indices of all positions that the input variable was found.
+
+  :params i_arrValues: The array to be searched
+  :params i_varValue: The variable to be searched for
+  :type i_arrValues: Array
+  :type i_varValue: Variable
+  :return: An array of all the locations that the input variable was found
+  :rtype: Array
+
+.. ven:function:: InitializeAllValues(array io_arrValues, variable i_varValue)
+
+  This function sets all values within an array to the input variable. Does not work on empty arrays. 
+
+  :params io_arrValues: The array in which all values will be converted. 
+  :params i_varValue: The variable to which all values will be converted.
+  :type io_arrValues: Array
+  :type i_varValue: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: IsBooleanArray(array i_arrValues)
+
+  This function checks whether all values in the array are booleans.
+
+  :params i_arrValues: The array to be checked
+  :type i_arrValues: Array
+  :return: A boolean of whether the input array is all booleans or not
+  :rtype: Boolean
+
+.. ven:function:: IsEmpty(array i_arrValues)
+
+  This function checks whether the input array is empty
+
+  :params i_arrValues: The array to be checked
+  :type i_arrValues: Array
+  :return: A boolean of whether the input array is empty or not
+  :rtype: Boolean
+
+.. ven:function:: IsFloatArray(array i_arrValues)
+
+  This function checks whether all values in the array are floats.
+
+  :params i_arrValues: The array to be checked
+  :type i_arrValues: Array
+  :return: A boolean of whether the input array is all floats or not
+  :rtype: Boolean
+
+.. ven:function:: IsIntegerArray(array i_arrValues)
+
+  This function checks whether all values in the array are integers.
+
+  :params i_arrValues: The array to be checked
+  :type i_arrValues: Array
+  :return: A boolean of whether the input array is all integers or not
+  :rtype: Boolean
+
+.. ven:function:: IsStringArray(array i_arrValues)
+
+  This function checks whether all values in the array are strings.
+
+  :params i_arrValues: The array to be checked
+  :type i_arrValues: Array
+  :return: A boolean of whether the input array is all strings or not
+  :rtype: Boolean
+
+.. ven:function:: Sort(array i_arrValues, variable i_intSortMode, o_bSuccessfulSorted)
+
+  This function outputs a sorted version of the array using the Shakersort sorting algorithm. All values in the array must share the same type for this function to work. Sort mode can either be 1 or 2, 1 is ascending and 2 is descending. 
+
+  :params i_arrValues: The array containing the values to be sorted  
+  :params i_intSortMode: Whether the array is to be sorted in ascending (1) or descending (2) order
+  :params o_bSuccesfulSorted: A boolean of whether the sort was successful or not
+  :type i_arrValues: Array
+  :type i_intSortMode: Variable
+  :type o_bSuccesfulSorted: Boolean
+  :return: A sorted copy of the array
+  :rtype: Array

Framework.txt

@@ -0,0 +1,25 @@
+Framework (from HSLExtensions)
+=========================
+
+https://github.com/theonetruenerd/VenusPackages/blob/main/Framework.pkg
+
+The framework library from HSLExtensions provides two visible functions, but is also required for a few of the other HSLExtension libraries. It uses the functionality of the ASW Standard TraceLevel library. The functions it adds are: 
+
+- :ven:func:`GetVersion`
+- :ven:func:`SetTraceLevel`
+
+.. ven:function:: GetVersion()
+
+  This function gets the framework version
+
+  :return: The framework version
+  :rtype: String
+
+.. ven:function:: SetTraceLevel(variable i_intTraceLevel)
+
+  This function sets the trace level of the framework.
+
+  :params i_intTraceLevel: The trace level, for the ASWStandard::TraceLevel library. 0 = TRACE_LEVEL_NONE, 1 = TRACE_LEVEL_RELEASE, 2 = TRACE_LEVEL_DEBUG.
+  :type i_intTraceLevel: Variable
+  :return: None
+  :rtype: N/A

TraceLevel.txt

@@ -0,0 +1,262 @@
+TraceLevel
+=================================
+
+https://github.com/theonetruenerd/VenusPackages/blob/main/TraceLevel.pkg
+
+The TraceLevel library adds a variety of functions related to the trace file. The functions it adds are:
+
+- :ven:func:`GetTraceLevel`
+- :ven:func:`SetTraceLevel`
+- :ven:func:`SetStringIndicator`
+- :ven:func:`Trace_02`
+- :ven:func:`Trace_04`
+- :ven:func:`Trace_06`
+- :ven:func:`Trace_08`
+- :ven:func:`Trace_10`
+- :ven:func:`TraceArray`
+- :ven:func:`TraceArrayHorizontally`
+- :ven:func:`TraceArraysFaceToFace`
+- :ven:func:`TraceSequence`
+- :ven:func:`TraceSequenceParameter`
+- :ven:func:`TraceSequencePositions`
+- :ven:func:`TraceAction`
+- :ven:func:`SetActionIndicator`
+
+.. ven:function:: GetTraceLevel()
+
+  This function returns the current trace level.
+
+  :return: This function returns one of the following predefined constants; TRACE_LEVEL_NONE (0), which corresponds to no traces at all. TRACE_LEVEL_RELEASE (1), which corresponds to only items with release trace level being traced. TRACE_LEVEL_DEBUG (2), which corresponds to everything being traced.
+  :rtype: Variable
+
+.. ven:function:: SetTraceLevel(variable i_intTraceLevel)
+
+  This function is used to set the trace level for the method or library.
+
+  :params i_intTraceLevel: The trace level for the library. Set to one of the following constants; TRACE_LEVEL_NONE (0), which corresponds to no traces at all. TRACE_LEVEL_RELEASE (1), which corresponds to only items with release trace level being traced. TRACE_LEVEL_DEBUG (2), which corresponds to everything being traced.
+  :type i_intTraceLevel: Variable (integer)
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: SetStringIndicator(variable i_strStringIndicatorCharacter)
+
+  This function is used to set one or more characters to indicate strings (by flanking them) in all traces. It can be useful to identify leading or trailing spaces in strings. You can do this by setting i_strStringIndicatorCharacter to \' or \*.
+
+  :params i_strStringIndicatorCharacter: Characters that are being added at the beginning and the end of each string trace.
+  :type i_strStringIndicatorCharacter: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: Trace_02(variable i_intTraceLevel, variable i_varToTrace_01, variable i_varToTrace_02)
+
+  This function is used to trace the value of 2 variables in one line. Will not automatically insert a space between the two variables.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_varToTrace_01: The first variable to trace.
+  :params i_varToTrace_02: The second variable to trace.
+  :type i_intTraceLevel: Variable
+  :type i_varToTrace_01: Variable
+  :type i_varToTrace_02: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: Trace_04(variable i_intTraceLevel, variable i_varToTrace_01, variable i_varToTrace_02, variable i_varToTrace_03, variable i_varToTrace_04)
+
+  This function is used to trace the value of 4 variables in one line. Will not automatically insert a space between the variables.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_varToTrace_01: The first variable to trace.
+  :params i_varToTrace_02: The second variable to trace.
+  :params i_varToTrace_03: The third variable to trace.
+  :params i_varToTrace_04: The fourth variable to trace.
+  :type i_intTraceLevel: Variable
+  :type i_varToTrace_01: Variable
+  :type i_varToTrace_02: Variable
+  :type i_varToTrace_03: Variable
+  :type i_varToTrace_04: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: Trace_06(variable i_intTraceLevel, variable i_varToTrace_01, variable i_varToTrace_02, variable i_varToTrace_03, variable i_varToTrace_04, variable i_varToTrace_05, variable i_varToTrace_06)
+
+  This function is used to trace the value of 6 variables in one line. Will not automatically insert a space between the variables.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_varToTrace_01: The first variable to trace.
+  :params i_varToTrace_02: The second variable to trace.
+  :params i_varToTrace_03: The third variable to trace.
+  :params i_varToTrace_04: The fourth variable to trace.
+  :params i_varToTrace_05: The fifth variable to trace.
+  :params i_varToTrace_06: The sixth variable to trace.
+  :type i_intTraceLevel: Variable
+  :type i_varToTrace_01: Variable
+  :type i_varToTrace_02: Variable
+  :type i_varToTrace_03: Variable
+  :type i_varToTrace_04: Variable
+  :type i_varToTrace_05: Variable
+  :type i_varToTrace_06: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: Trace_08(variable i_intTraceLevel, variable i_varToTrace_01, variable i_varToTrace_02, variable i_varToTrace_03, variable i_varToTrace_04, variable i_varToTrace_05, variable i_varToTrace_06, variable i_varToTrace_07, variable i_varToTrace_08)
+
+  This function is used to trace the value of 8 variables in one line. Will not automatically insert a space between the variables.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_varToTrace_01: The first variable to trace.
+  :params i_varToTrace_02: The second variable to trace.
+  :params i_varToTrace_03: The third variable to trace.
+  :params i_varToTrace_04: The fourth variable to trace.
+  :params i_varToTrace_05: The fifth variable to trace.
+  :params i_varToTrace_06: The sixth variable to trace.
+  :params i_varToTrace_07: The seventh variable to trace.
+  :params i_varToTrace_08: The eighth variable to trace.
+  :type i_intTraceLevel: Variable
+  :type i_varToTrace_01: Variable
+  :type i_varToTrace_02: Variable
+  :type i_varToTrace_03: Variable
+  :type i_varToTrace_04: Variable
+  :type i_varToTrace_05: Variable
+  :type i_varToTrace_06: Variable
+  :type i_varToTrace_07: Variable
+  :type i_varToTrace_08: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: Trace_10(variable i_intTraceLevel, variable i_varToTrace_01, variable i_varToTrace_02, variable i_varToTrace_03, variable i_varToTrace_04, variable i_varToTrace_05, variable i_varToTrace_06, variable i_varToTrace_07, variable i_varToTrace_08, variable i_varToTrace_09, variable i_varToTrace_10)
+
+  This function is used to trace the value of 10 variables in one line. Will not automatically insert a space between the variables.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_varToTrace_01: The first variable to trace.
+  :params i_varToTrace_02: The second variable to trace.
+  :params i_varToTrace_03: The third variable to trace.
+  :params i_varToTrace_04: The fourth variable to trace.
+  :params i_varToTrace_05: The fifth variable to trace.
+  :params i_varToTrace_06: The sixth variable to trace.
+  :params i_varToTrace_07: The seventh variable to trace.
+  :params i_varToTrace_08: The eighth variable to trace.
+  :params i_varToTrace_09: The ninth variable to trace.
+  :params i_varToTrace_10: The tenth variable to trace.
+  :type i_intTraceLevel: Variable
+  :type i_varToTrace_01: Variable
+  :type i_varToTrace_02: Variable
+  :type i_varToTrace_03: Variable
+  :type i_varToTrace_04: Variable
+  :type i_varToTrace_05: Variable
+  :type i_varToTrace_06: Variable
+  :type i_varToTrace_07: Variable
+  :type i_varToTrace_08: Variable  
+  :type i_varToTrace_09: Variable
+  :type i_varToTrace_10: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceArray(variable i_intTraceLevel, variable i_strDescription, array i_arrvarToTrace)
+
+  This function is used to trace an array of variables. It will trace each value of the array in its own line, along with the array description and the index of the value.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_strDescription: A description of the array, which will be at the start of each line of the array trace.
+  :params i_arrvarToTrace: The array to be traced.
+  :type i_intTraceLevel: Variable
+  :type i_strDescription: Variable
+  :type i_arrvarToTrace: Array (of variables)
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceArrayHorizontally(variable i_intTraceLevel, variable i_strDescription, array i_arrvarToTrace)
+
+  This function is used to trace an array of variables. It will trace the array description, followed by each array index and value pair, all on one line.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_strDescription: A description of the array, which will be at the start of the array trace.
+  :params i_arrvarToTrace: The array to be traced.
+  :type i_intTraceLevel: Variable
+  :type i_strDescription: Variable
+  :type i_arrvarToTrace: Array (of variables)
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceArraysFaceToFace(variable i_intTraceLevel, variable i_strDescription_1, variable i_strDescription_2, array i_arrvarToTrace_1, array i_arrvarToTrace_2)
+
+  This function is used to trace two arrays of variables at the same time, with values at the same index being shown on the same line as one another.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_strDescription_1: A description of the first array, which will be at the start of the array trace.
+  :params i_strDescription_2: A description of the second array, which will be at the start of the array trace.
+  :params i_arrvarToTrace_1: The first array to be traced.
+  :params i_arrvarToTrace_2: The second array to be traced.
+  :type i_intTraceLevel: Variable
+  :type i_strDescription_1: Variable
+  :type i_strDescription_2: Variable
+  :type i_arrvarToTrace_1: Array (of variables)
+  :type i_arrvarToTrace_2: Array (of variables)
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceSequence(variable i_intTraceLevel, sequence i_seqToTrace)
+
+  This function is used to trace a sequence. It will list the sequence name, current position, the count and total positions in the sequence, the max number of positions available, and the number of used positions. It will then list the labware ID and position ID for each value of the sequence.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_seqToTrace: The sequence to be traced
+  :type i_intTraceLevel: Variable
+  :type i_seqToTrace: Sequence
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceSequenceParameter(variable i_intTraceLevel, sequence i_seqToTrace)
+
+  This function is used to trace the parameters of a sequence. It will list the sequence name, current position, the count and total positions in the sequence, the max number of positions available, and the number of used positions.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_seqToTrace: The sequence to be traced
+  :type i_intTraceLevel: Variable
+  :type i_seqToTrace: Sequence
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceSequencePositions(device ML_STAR, variable i_intTraceLevel, sequence i_seqToTrace, variable i_blnCurrentPositionOnly)
+
+  This function is used to trace the deck positions of a sequence. It will trace the sequence name, then for each part of the sequence it will trace the position ID and the x, y, z, and r coordinates of the position.
+
+  :params ML_STAR: The STAR device.
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_seqToTrace: The sequence to be traced
+  :params i_blnCurrentPositionOnly: A boolean determining whether the function will trace positions for all sequence positions (0) or just the current sequence position (1).  
+  :type ML_STAR: Device
+  :type i_intTraceLevel: Variable
+  :type i_seqToTrace: Sequence
+  :type i_blnCurrentPositionOnly: Boolean
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: TraceAction(variable i_intTraceLevel, variable i_intAction, variable i_strFunctionName, variable i_strMethodName, variable i_strComment)
+
+  This function is used to trace different action states for a module. :ven:func:`SetActionIndicator` can be used to help identify actions in log files more easily.
+
+  :params i_intTraceLevel: The trace level for the entry. Can be set to either TRACE_LEVEL_RELEASE (1) or TRACE_LEVEL_DEBUG (2). If set to 1, the function will show up in the trace when the trace level is set to either TRACE_LEVEL_RELEASE or TRACE_LEVEL_DEBUG, if set to 2, the function will only show up when the trace level is TRACE_LEVEL_DEBUG.
+  :params i_intAction: The action to be traced. Set to one of the following constants. START (1) corresponds to the entry being traced as starting. COMPLETE (2) corresponds to the entry being traced as finished successfully. ERROR (3) corresponds to the entry being traced as error occurred. PROGRESS (4) corresponds to the entry being traced as progressing. COMPLETE_WITH_ERROR (5) corresponds to the entry being traced as finished unsuccessfully.
+  :params i_strFunctionName: The function name for the action trace. Can be set to the return value of the HSL function *GetFunctionName*, which will automatically be formatted correctly.
+  :params i_strMethodName: The method name for the action trace. Can be set to the return value of the HSL function *GetMethodFileName*, which will automatically be formatted correctly.
+  :params i_strComment: A comment to be traced with the action trace.
+  :type i_intTraceLevel: Variable
+  :type i_intAction: Variable
+  :type i_strFunctionName: Variable
+  :type i_strMethodName: Variable
+  :type i_strComment: Variable
+  :return: None
+  :rtype: N/A
+
+.. ven:function:: SetActionIndicator(variable i_intAction, variable i_strIndicator)
+
+  This function is used to set one or more characters to indicate actions. By setting *i_strIndicator* to different characters you can make it easy to identify different actions in the trace.
+
+  :params i_intAction: The action to be traced. Set to one of the following constants. START (1) corresponds to the entry being traced as starting. COMPLETE (2) corresponds to the entry being traced as finished successfully. ERROR (3) corresponds to the entry being traced as error occurred. PROGRESS (4) corresponds to the entry being traced as progressing. COMPLETE_WITH_ERROR (5) corresponds to the entry being traced as finished unsuccessfully.
+  :params i_strIndicator: Character(s) that are being repeated at a total length of up to 100 and traced before and after the action trace.
+  :type: i_intAction: Variable
+  :type i_strIndicator: Variable
+  :return: None
+  :rtype: N/A
+

Windows.txt

@@ -0,0 +1,50 @@
+Windows (from HSLExtensions)
+=========================================
+
+https://github.com/theonetruenerd/VenusPackages/blob/main/Windows.pkg
+
+The windows library from HSLExtensions adds functions related to registries and special directories. The functions it adds are as follows:
+
+- :ven:func:`GetRegistryValue`
+- :ven:func:`GetSpecialDirectory`
+- :ven:func:`SetRegistryValue`
+
+.. ven:function:: GetRegistryValue(variable i_intHKey, variable i_strKey, variable i_strValueName, variable o_varValue)
+
+  This function reads a value from the specified registry
+
+  :params i_intHKey: The main key of the registry. 1 = ClassesRoot, 2 = CurrentUser, 3 = LocalMachine, 4 = Users, 5 = CurrentConfig.
+  :params i_strKey: The key to the path (e.g. SOFTWARE\Phoenix\Directories\Methods)
+  :params i_strValueName: The name of the value to be read
+  :params o_varValue: The value which was read (type according to value type)
+  :type i_intHKey: Integer
+  :type i_strKey: String
+  :type i_strValueName: String
+  :type o_varValue: Variable
+  :return: Boolean showing whether the key exists (hslTrue) or not (hslFalse)
+  :rtype: Boolean
+
+.. ven:function:: GetSpecialDirectory(variable i_intSpecialDirectory)
+
+  This function gets the specified special directory
+
+  :params i_intSpecialDirectory: The type of the special directory. 1 = WindowsDirectory, 2 = SystemDirectory, 3 = TemporaryDirectory.
+  :type i_intSpecialDirectory: Integer
+  :return: The special directory
+  :rtype: String
+
+.. ven:function:: SetRegistryValue(variable i_intHKey, variable i_strKey, variable i_strValueName, variable i_varValue, variable i_intValueType)
+
+  This function writes a value to the specified registry
+
+  :params i_intHKey: The main key of the registry. 1 = ClassesRoot, 2 = CurrentUser, 3 = LocalMachine, 4 = Users, 5 = CurrentConfig.
+  :params i_strKey: The key to the path (e.g. SOFTWARE\Phoenix\Directories\Methods)
+  :params i_strValueName: The name of the value to be read
+  :params i_varValue: The value which was will be written in
+  :params i_intValueType: The type of the value. 1 = String, 2 = Number, 3 = Binary, 4 = ExpandableString
+  :type i_intHKey: Integer
+  :type i_strKey: String
+  :type i_strValueName: String
+  :type o_varValue: Variable
+  :return: Boolean showing whether the function was successful (hslTrue) or not (hslFalse)
+  :rtype: Boolean

ZerouLScanner.txt

@@ -0,0 +1,15 @@
+Zero uL Scanner
+=========================
+
+https://github.com/theonetruenerd/VenusPackages/blob/main/ZerouLScanner.pkg
+
+The zero uL scanner library adds a single function which is designed to be added at the end of a method. It scans the trace file for any steps in which 0uL was pipetted and returns the number of times that happened. This is to check for steps where (for example) it is pipetting a volume based on a variable, and there is a spelling mistake in the variable, or the variable isn't defined correctly. It will work in both simulation mode and normal mode.
+
+- :ven:func:`CheckFor0s`
+
+.. ven:function:: CheckFor0s()
+
+  This function checks for any steps in which 0uL has been pipetted and returns the number of times that has happened.
+
+  :return: Number of times 0uL has been pipetted
+  :rtype: Variable

venus.txt

@@ -0,0 +1,279 @@
+Venus
+==============================================
+
+This section aims to cover the *functions* that Venus can run. Documentation on more general principles of Venus, including things like the liquid editor and labware editor, will be found separately.
+
+Venus functions are organised into several sections. These are the following:
+
+
+  - :ref:`General Steps`
+  - :ref:`Scheduler Steps`
+  - :ref:`Custom Dialog Steps`
+  - :ref:`Favourites`
+  - :ref:`Templates`
+
+There are also instrument specific functions in their own categories:
+
+  - :ref:`ML_STAR`
+  - :ref:`Microlab STAR Smart Steps`
+
+.. General Steps
+
+  The general steps are composed of relatively standard coding functions that will be present in many other coding languages. These are not associated with the hardware of any instrument and are present on Venus regardless of whether you are using a STAR, a STARLet, or any other instrument which uses Venus. The functions which fall under general steps are listed below:
+
+  - :ven:func:`Comment`
+  - :ven:func:`Assignment`
+  - :ven:func:`Assignment with Calculation`
+  - :ven:func:`Loop`
+  - :ven:func:`Loop: Break`
+  - :ven:func:`If, Else`
+  - :ven:func:`Array: Declare / Set Size`
+  - :ven:func:`Array: Set At`
+  - :ven:func:`Array: Get At`
+  - :ven:func:`Array: Get Size`
+  - :ven:func:`Array: Copy`
+  - :ven:func:`Sequence: Get Current Position`
+  - :ven:func:`Sequence: Set Current Position`
+  - :ven:func:`Sequence: Get End Position`
+  - :ven:func:`Sequence: Set End Position`
+  - :ven:func:`Adjust Sequences`
+  - :ven:func:`File: Open`
+  - :ven:func:`File: Read`
+  - :ven:func:`File: Write`
+  - :ven:func:`File: Set Position`
+  - :ven:func:`File: Close`
+  - :ven:func:`Timer: Start`
+  - :ven:func:`Timer: Wait for`
+  - :ven:func:`Timer: Read Elapsed Time`
+  - :ven:func:`Timer: Restart`
+  - :ven:func:`User Input`
+  - :ven:func:`User Output`
+  - :ven:func:`Shell`
+  - :ven:func:`Set Event`
+  - :ven:func:`Wait for Event`
+  - :ven:func:`Return`
+  - :ven:func:`Abort`
+  - :ven:func:`Error Handling by the User`
+  - :ven:func:`Begin Parallel`
+  - :ven:func:`End Parallel`
+
+.. Scheduler Steps
+
+  The scheduler steps are functions which arrange the method to be executed on a number of resources and submitted to capacity, time and precedence relations in a way that fulfils the optimality criteria. The methods and its activation criterions are defined in a workflow.
+
+The Schedule process is divided into two phases: scheduling and executing. The scheduler functions are listed below:
+
+  - :ven:func:`Select Method`
+  - :ven:func:`Activate Task`
+  - :ven:func:`Cancel Task`
+  - :ven:func:`Schedule Block`
+  - :ven:func:`Reschedule`
+
+.. Custom Dialog Steps
+
+  The custom dialog steps only adds the :ven:func:`Custom Dialog` function, which allows creation of more complicated dialogs than the standard :ven:func:`User Input` and :ven:func:`User Output` functions. 
+
+.. Favourites
+
+  The favourites drop-down allows you to select functions which you use frequently to be in their own separate tab so that they are easier to find. These steps will be favourited on every method.
+
+.. Templates
+
+  Templates add the ability to preprogram commonly used functions and processes/sets of functions so that the user doesn't have to write them freshly every time. An example might be a tip pickup step with all the parameters for pickup already programmed in so you don't have to fill them in, or a bulk creation of arrays for an ASW Dialog.
+
+.. ML_STAR
+
+  The ML_STAR section adds the core functions which interact with the ML_STAR itself, which is anything that interacts with the hardware or firmware of the STAR. They are split into the power steps and single steps. The single steps are then split into liquid handling functions, preparation functions, transport functions, and miscellaneous functions. The functions which come under the ML_STAR tab are:
+
+- :ven:func:`1000ul Channel Aspirate`
+- :ven:func:`1000ul Channel Dispense`
+- :ven:func:`CO-RE 96 Head Aspirate`
+- :ven:func:`CO-RE 96 Head Dispense`
+- :ven:func:`iSWAP Transport`
+- :ven:func:`1000ul Channel CO-RE Grip Transport`
+- :ven:func:`1000ul Channel Tip Pick Up (Single Step)`
+- :ven:func:`1000ul Channel Aspirate (Single Step)`
+- :ven:func:`1000ul Channel Dispense (Single Step)`
+- :ven:func:`1000ul Channel Dispense on the Fly (Single Step)`
+- :ven:func:`1000ul Channel Tip Eject (Single Step)`
+- :ven:func:`1000ul Channel Get Last Liquid Level (Single Step)`
+- :ven:func:`1000ul Channel Aspirate 2nd Phase (Single Step)`
+- :ven:func:`CO-RE 96 Head Tip Pick Up (Single Step)`
+- :ven:func:`CO-RE 96 Head Aspirate (Single Step)`
+- :ven:func:`CO-RE 96 Head Dispense (Single Step)`
+- :ven:func:`CO-RE 96 Head Tip Eject (Single Step)`
+- :ven:func:`Initialize (Single Step)`
+- :ven:func:`Calibrate Carrier (Single Step)`
+- :ven:func:`Lock/Unlock Front Cover (Single Step)`
+- :ven:func:`iSWAP Get Plate (Single Step)`
+- :ven:func:`iSWAP Place Plate (Single Step)`
+- :ven:func:`iSWAP Move Plate (Single Step)`
+- :ven:func:`iSWAP Open Gripper (Single Step)`
+- :ven:func:`iSWAP Close Gripper (Single Step)`
+- :ven:func:`iSWAP Get First Plate Position (Single Step)`
+- :ven:func:`iSWAP Park (Single Step)`
+- :ven:func:`1000ul Channel CO-RE Grip Get Plate (Single Step)`
+- :ven:func:`1000ul Channel CO-RE Grip Place Plate (Single Step)`
+- :ven:func:`1000ul Channel CO-RE Grip Move Plate (Single Step)`
+
+.. Microlab STAR Smart Steps
+
+  Smart steps are functions which are preprogrammed single steps which are combined to be ready for specific tasks such as doing both aspiration and dispensing of a reagent in the same function. The Smart Step functions are:
+
+- :ven:func:`Advanced Load Settings`
+- :ven:func:`Load`
+- :ven:func:`Load and Match`
+- :ven:func:`1000ul Channel Pipette - Simple (1-1)`
+- :ven:func:`1000ul Channel Pipette - Replica (1-n)`
+- :ven:func:`1000ul Channel Pipette - Pooling (n-1)`
+- :ven:func:`1000ul Channel Pipette - Aliquot`
+- :ven:func:`Unload`
+- :ven:func:`1000ul Channel Needle Wash Settings`
+- :ven:func:`1000ul Channel Needle Pick Up`
+- :ven:func:`1000ul Channel Needle Eject`
+- :ven:func:`1000ul Channel Tip Pick Up`
+- :ven:func:`1000ul Channel Tip Eject`
+
+How venus works
+-------------------------------------------------------
+
+Venus is a drag-and-drop wrapper for a separate coding language called HSL, standing for Hamilton Standard Language. When coding a method in Venus, all the available functions (core and any from imported libraries) are listed on the left hand side of the screen in a tree view. When you want to add a step to your method, you drag and drop that function from the left hand side and drop it wherever you want it to be in your method. This will then open a dialog box which allows you to input your desired parameters. The method is saved as a .med file, which can be run through a software called HxRunControl.exe. The run control software can run simulations of the code as well as the code on an actual robot. In the run control software window, you can see the deck layout dynamically changing, an open view of the method showing what step you are on, and a trace file which is a type of log which displays the data from every step that is occuring and is timestamped for each step. The trace file is saved to the Log Files folder within the main Hamilton folder in Program Files (x86). Method files (.med) can compile into HSL files (.hsl) which can also be edited and run through the run control software. Instead of being drag-and-drop, HSL is a more standard coding language, with C++ like syntax. HSL files cannot be converted into .med files; as such, it is usually recommended to insert snippets of HSL code into the main .med file rather than coding in HSL itself, or to only use HSL for creation of fresh libraries. 
+
+Libraries are groups of functions which reside in the library folder within the main Hamilton folder. They can be imported into specific methods, at which point the functions associated with that library will appear in the function tree on the left hand side of the method editor. Libraries can either be written in HSL (and are thus .hsl files) or can be "sub-method libraries", which is a series of steps coded in Venus that are stored in a way that works like a function. Sub-method libraries are .smt files. You can have submethods in a normal method file, and it is often encouraged so that your code is "parcelled" into blocks which contain the main blocks of your method. These submethods are just like the normal method but reside in a separate tab in the method editor. 
+
+The following function groups are not libraries and instead are "core" groups which do not need importing; every other function referenced is part of a library.
+  - General Steps
+  - Scheduler Steps
+  - Custom Dialog Steps
+  - Favourites
+  - Templates
+  - ML_STAR
+  - Microlab STAR Smart Steps
+
+When pipetting using the 1000ul channels, there are 8 channels total. Channel patterns (which determine which channels are in use at any given point in time) are written in the form of a string of 1s and 0s, where 0 is not in use and 1 is in use. For example, if using channels 2, 3, and 5, the channel pattern would be "01101000". All pipetting steps require a channel pattern input as one of the parameters. Unless specified, the priority of the channels should always be to use the channels with lower indices. 
+
+There are several different tip types available for an ML_STAR, the most commonly used are 300ul (Standard volume, tip id 0), and 50ul (tip id 22). You can also get 10ul tips and 1000ul tips. All tips have the option of being normal, stackable, or filtered. No tip can take up more liquid than its type (i.e. a 300uL tip cannot ever have more than 300ul total volume in it). The 300ul tips should not be used to go below 10ul as they become very inaccurate. When pipetting, the total volume in a channel is the amount of liquid that has been aspirated by that channel minus the amount of liquid that has been dispensed by that channel. 
+
+For arrays in venus, you have to declare the size of the array (which can be empty) and then add items one by one; with the core functions you can't add more than one item at once. To add an item you can either specify an index or add to the end of the array; when adding to an empty array you can only add to the end of the array. Arrays in venus are 1-based rather than 0-based.
+
+For variable naming in venus, the following convention should be followed. If a variable is an integer, it should be prefixed with "int_". If it is a float, it should be prefixed with "flt_". If it is a timer, it should be prefixed with "timer_". If it is a loop counter, it should be prefixed with "loop_". If it is an array, it should be prefixed with "arr_". If it is an array of sequences, it should be prefixed with "arrseq_". If it is a sequence, it should be prefixed with "seq_". If it is an unknown variable type, it should be prefixed with "var_". If it is known to be a variable only used as input to functions, it should have an "i_" between the prefix and the variable name. If it is known to be a variable only used to store outputs from functions, it should have an "o_" between the prefix and the variable name. If it is known to be both an input and output variable, i.e. something which is input into a function and modified during the function and then the modified value is returned, it should have an "io_" between the prefix and variable name. If it is unknown whether it is an input or output variable, there is nothing extra between the prefix and variable name. 
+
+For creation of reaction mixes, if unspecified, you should add in the following order:
+  - Water
+  - Buffers
+  - Beads
+  - DNA
+  - ATP
+  - Enzymes.
+
+If the substance type is unknown, then prioritise adding high volumes before low volumes. In the code, functions do not have the :ven:func` prefix. 
+
+Microlab STARs have something called TADM; this is a pressure monitoring system of within pipetting steps, standing for Total Air Displacement Monitoring. The pressure data is saved in 10ms timepoints in a microsoft access database, along with the channel number, timestamp, and liquid class being used for the specific pipetting step that the TADM data was generated from. With the TADMCurveExport library, you can export the TADM data from the Microsoft Access Database file into an Excel file or a set of CSV files automatically. The TADM data can also be uploaded into the liquid class database to be associated with the specific liquid classes involved. You can set TADM tolerance bands within the liquid class database, which can cause the method to abort if TADM pressure data goes outside of the tolerance bands. The TADM data can also be used to analyze success of pipetting steps as incorrect/flawed pipetting (e.g. generating bubbles) will cause noticeable changes in the TADM data. 
+
+By default, make timers have the "is stoppable" parameter set to True. 
+
+Venus functions are denoted in the documentation by the ven:function:: prefix in the function definition and :ven:func: in the function references. 
+
+General Steps
+-------------------------------------------------------
+
+.. ven:function:: Comment
+
+  The comment function allows you to input a comment into the method. The comment can be chosen to be a Trace comment or not. If it is a Trace comment, it will be printed in the Trace during simulated or real runtime. Comment steps can also be chosen to be a specific colour in the editor, unlike most functions. The comment function doesn't have any input parameters, just a popup text box which you can input ASCII characters into. Pressing <Ctrl> + <Enter> will insert a new line. Pressing <Ctrl> + <Tab> will indent the text.
+
+.. ven:function:: Assignment
+
+  The assignment function allows you to specify a variable and assign a value to it. It does not have any input parameters but instead a box in which you can input the name of your variable and the value you wish to assign to it. The variable name can be a fresh name, or can be an existing one which you are reassigning a value to, or an element from an array. The value to be assigned can be a signed number, a string, an entry from a given list, another variable name, or an element from an array. If entering a string, the option to have it as a Translatable string is available, which can be translated into different languages using the Translation Support System provided by the Hamilton Company.
+
+Scheduler Steps
+-------------------------------------------------
+
+Custom Dialog Steps
+-------------------------------------------------
+
+Favourites
+-------------------------------------------------
+
+Templates
+-------------------------------------------------
+
+ML_STAR
+-------------------------------------------------
+
+.. ven:function:: 1000ul Channel Tip Pick Up (Single Step)
+
+  The 1000ul Channel Tip Pick Up (Single Step) function tells the Microlab STAR to pick up tips with the 1000ul channels. It asks for the input sequence where it can find the tips and whether the sequence counting is automatic (i.e. the starting position of the sequence increments when tips are picked up) or manual (no increments). It also allows you to select which channels are being used to pick up tips by assigning it a channel pattern, which can either be input directly in the dialog box or as a variable. It allows you to set custom error handling in response to specific errors that will potentially occur during the step, such as automatically testing the next spot in the sequence if no tips are found.
+
+.. ven:function:: 1000ul Channel Aspirate (Single Step)
+
+  The 1000ul Channel Aspirate (Single Step) function tells the Microlab STAR to use the specified channels to aspirate liquid from the specified sequence. It requires an input sequence telling it where to locate the desired liquid, as well as a boolean determining whether sequence counting is automatic (i.e. increments starting position after aspiration) or manual (i.e. no increment). It asks for a volume input, which can be a variable, and allows individual volumes to be set for each channel if desired. It also allows you to switch between three types of aspiration; normal, consecutive aspiration, and aspirate all. Aspirate all will attempt to aspirate a set volume, and if not enough is present it won't throw an error, it will simply take whatever is present. 
+  For the pipetting cycle settings, you can pick what tip type you want to use from the dropdown, as well as what dispense mode you wish to use. The dispense mode selected will then act as a filter for what liquid classes are available in the next drop-down. You can select your desired liquid class from the dropdown, either as a string name from the liquid class database, or as a variable. 
+  The aspirate position settings allow you to control the height in which the pipette will try aspirate, through a variety of different settings and options. The default is to use capacitive liquid level detection (cLLD) at the sensitivity defined by the labware definition (5). You can also change this sensitivity to be higher or lower. You can also turn on pressure liquid level detection (pLLD) which measures increases in pressure in the tip and uses that to determine liquid level height. You can set a submerge depth in mm, which tells the pipettes how far below the surface they are to go once they have identified the liquid height. If both pLLD and cLLD are on, you can set a maximum height difference, in which case if the values do not agree and are outside this set range, the method will abort. If neither pLLD or cLLD is on, you can set it to either aspirate a fixed height from the bottom of the labware, or to touch off the bottom of the labware and then rise a little bit.
+  The channel settings available allow you to select which channels are being used in the aspiration, which can be either selected via tickboxes, input directly into the dialog box, or input as a variable. The advanced settings let you control whether or not the pipette tips follow the changing liquid height during aspiration and mixing, as well as letting you add mixing cycles to the pipetting step, of a specified volume, position, and number of cycles. The error section lets you set custom error handling responses to specific errors that will potentially occur during the process, and the responses are automatically triggered upon the error. 
+
+.. ven:function:: 1000ul Channel Dispense (Single Step)
+
+  The 1000ul Channel Dispense (Single Step) function tells the Microlab STAR to use the specified channels to aspirate liquid from the specified sequence. It requires an input sequence telling it which piece of labware to dispense the desired liquid into, as well as a boolean determining whether sequence counting is automatic (i.e. increments starting position after aspiration) or manual (i.e. no increment). It asks for a volume input, which can be a variable, and allows individual volumes to be set for each channel if desired. The dispense mode can be chosen from a dropdown, and the default value is 8, which means it will use the liquid class specified in the previous aspiration step.
+  The dispense position settings allow you to control the height in which the pipette will try to dispense, through a variety of different settings and options. The default is to use capacitive liquid level detection (cLLD) at the sensitivity defined by the labware definition (5). You can also change this sensitivity to be higher or lower. You can also turn on pressure liquid level detection (pLLD) which measures increases in pressure in the tip and uses that to determine liquid level height. You can set a submerge depth in mm, which tells the pipettes how far below the surface they are to go once they have identified the liquid height. If both pLLD and cLLD are on, you can set a maximum height difference, in which case if the values do not agree and are outside this set range, the method will abort. If neither pLLD or cLLD is on, you can set it to either dispense a fixed height from the bottom of the labware, or to touch off the bottom of the labware and then rise a little bit. If the labware has been defined with the "Side Touch" characteristic, the channels can also do a side touch dispense, in which it will enter the well and then move the pipette tip to touch the side of the well at the specified height, allowing it to dispense on the side of the well, usually for the benefits of not making contact with the well bottom, or for the wicking effect. 
+  The channel settings available allow you to select which channels are being used in the dispense, which can be either selected via tickboxes, input directly into the dialog box, or input as a variable. The advanced settings let you control whether or not the pipette tips follow the changing liquid height during aspiration and mixing, as well as letting you add mixing cycles to the pipetting step, of a specified volume, position, and number of cycles. The error section lets you set custom error handling responses to specific errors that will potentially occur during the process, and the responses are automatically triggered upon the error. 
+
+.. ven:function:: 1000ul Channel Dispense on the Fly (Single Step)
+
+  The 1000ul Channel Dispense on the Fly (Single Step) function tells the Microlab STAR to dispense liquid continuously from the specified channel whilst moving at a set speed and distance, usually defined as a complete plate. You input the destination sequence, as well as whether sequence counting is automatic (1) or manual (0). If sequence counting is automatic, the next time it interacts with the sequence, it will treat the next untouched posiiton in the sequence as the first position in the sequence. You can input your desired total dispense volume, either as a variable or raw value, and you can also specify different volumes for each channel, which can be variables, elements from an array, or raw values. The dispense on the fly mode can either be set to complete plate (0) or sequence order (1). You can set the dispense position with two parameters; the labware surface distance in mm (which can either be input as a variable or raw value), and the Start X-offset in mm (which can also be input as a variable or raw value). In the pipetting arm section you can input the X-speed during the dispense, in mm/s (which can be input as a variable or raw value). 
+  The channel settings available allow you to select which channels are being used in the dispense, which can be either selected via tickboxes, input directly into the dialog box, or input as a variable. The advanced settings let you control whether the liquid class being used is the same as in the first aspiration of the cycle, and if not then it lets you pick a fresh liquid class. It also allows you to determine the X-acceleration distance before the first shoot in mm, the dispense direction (with 0 being serpentine and 1 being from the left only), as well as specifying any excluded labware positions. The error section lets you set custom error handling responses to specific errors that will potentially occur during the process, and the responses are automatically triggered upon the error. 
+
+.. ven:function:: 1000ul Channel Tip Eject (Single Step)
+
+  The 1000ul Channel Tip Eject (Single Step) function tells the Microlab STAR to eject tips from the specified channels. You input the eject destination, which is any piece of labware, but by default is (1) which corresponds to the default waste location on the Microlab STAR. If a separate eject destination is chosen, sequence counting can be turned to automatic (i.e. increment sequence after ejecting tips) or manual (no increment).
+  The channel settings allow you to select which channels the tips are being ejected from, whcih can either be selected via tickboxes, input directly into the dialog box, or input as a variable. The error settings let you set custom error handling responses to specific errors that will potentially occur during the process, and the responses are automatically triggered upon the error.
+
+.. ven:function:: 1000ul Channel Get Last Liquid Level (Single Step)
+
+  The 1000ul Channel Get Last Liquid Level (Single Step) function returns the liquid level height detected during the most recently performed aspirate or dispense step with liquid level detection enabled. There is no dialog box that appears as there are no parameters to input. It returns three values; the channel number, the detected liquid level height in mm relative to the deck coordinates of the Microlab STAR, and the block data for each channel.
+
+.. ven:function:: 1000ul Channel Aspirate 2nd Phase (Single Step)
+
+  The 1000ul Channel Aspirate 2nd Phase (Single Step) function allows you to aspirate a second phase of liquid into a tip that already has liquid in it. You input a target sequence for it to aspirate from, and input whether sequence counting is automatic (1) or manual (0). If automatic, the next time it interacts with a sequence it will treat the first untouched well as the start of the sequence. You can input the volume in ul either as a variable or raw value, or can input individual volumes for each channel as variables, raw values, or array elements. You can set the aspiration mode to 0 (aspiration) or 2 (aspirate all). Aspirate all will remove all available liquid in the well up to the specified volume without throwing errors if there is too little liquid. 
+  In the pipetting cycle settings you can input what tip type you are using and the dispense mode, which will then provide a filter for the liquid classes that are available for you to select to use, which are chosen from the liquid class database. You can also set the aspiration position. You can use capacitive liquid level detection (cLLD) to determine the liquid level height, at a variety of sensitivities, with 5 being the default (which means "set in the labware definition" for the specific piece of labware being interacted with). You can have pressure liquid level detection (pLLD) on instead of or as well as cLLD. This uses pressure changes in the tip to determine what the liquid level is. If using both pLLD and cLLD, you can input a max height difference in mm, which will cause an error if the detected height from the cLLD and pLLD differ by more than the set value. You also input a submerge depth in mm which determines how far below the detected liquid level the tip goes before beginning the aspiration. 
+  The channel settings available allow you to select which channels are being used in the dispense, which can be either selected via tickboxes, input directly into the dialog box, or input as a variable. The advanced settings let you control the immersion depth for the aspiration in mm, and whether liquid following during aspiration is on (1) or off (0). The advanced settings also let you input the Z speed of Search Level, in mm/s, and the dispenser stream of Search Level, in ul/s. Lastly, the advanced settings let you control the dispense back parameters, allowing you to input a retract distance in mm and a dispense stream in ul/s. The error section lets you set custom error handling responses to specific errors that will potentially occur during the process, and the responses are automatically triggered upon the error. 
+
+.. ven:function:: Initialize (Single Step)
+
+  The Initialize (Single Step) function initializes the Microlab STAR. It is required to be called the first time the STAR is used after being turned on. It is sensible to put it at the beginning of every method. It can either always initialize (1) or only initialize for the first run when turned on (0). The error settings dialog allows you to input automatic responses to certain errors. 
+
+.. ven:function:: Lock/Unlock Front Cover (Single Step)
+
+  The Lock/Unlock Front Cover (Single Step) function locks or unlocks the protective cover of the Microlab STAR. It can either be set to 1 (locked) or 0 (unlocked). The error settings dialog allows you to input automatic responses to certain errors.
+
+.. ven:function:: iSWAP Get Plate (Single Step)
+
+  The iSWAP Get Plate (Single Step) function uses the iSWAP (if the instrument has one installed) to pick up a plate from a specified position, in preparation for either an iSWAP Move Plate or iSWAP Place Plate function to be called. You specify the sequence of the plate to be picked up, as well as the lid sequence if it has a lid. You specify whether sequence counting is automatic (1) or manual (0); usually it is manual, it is automatic if you plan on moving multiple plates which are in the same sequence. You can set the iSWAP grip parameters, which are the grip height in mm, measured from the top of the labware, and the grip mode - this can be gripping the labware on the small side (0; the default) or the long side (1). Most labware comes with data in the labware file as to what grip width is required and the opening width before access, but this function has the option to override that, in which case you can put in the grip width and opening width before access, both in mm. The movement can either be just to a carrier (0; default) or a complex movement (1). The transport mode can be set to 0 (plate only), 1 (lid only) or 2 (plate and lid). If complex movement is chosen, three more parameters have to be input: the retract distance in mm, the lift-up height in mm, and the labware orientation, which can either be 1, 2, 3 or 4, based on which of the cardinal directions the iSWAP is pickup up the labware from. 
+  The advanced setting dialog allows you to set the iSWAP grip force (default 5, goes between 0 and 10), as well as the tolerance in mm, whether the grip is inverse (1) or normal (0), and whether collision control is on (1) or off (0). The error settings dialog allows you to program in automatic responses to specific errors. 
+
+.. ven:function:: iSWAP Place Plate (Single Step)
+
+  The iSWAP Place Plate (Single Step) function allows the iSWAP to move to a specified location and place down a plate if it is holding one. You input the target sequence which is the location you wish the iSWAP place the plate in, as well as the lid sequence if the plate has a lid. The movement can either be just to a carrier (0; default) or a complex movement (1). The transport mode can be set to 0 (plate only), 1 (lid only) or 2 (plate and lid). If complex movement is chosen, three more parameters have to be input: the retract distance in mm, the lift-up height in mm, and the labware orientation, which can either be 1, 2, 3 or 4, based on which of the cardinal directions the iSWAP is pickup up the labware from. You specify whether sequence counting is automatic (1) or manual (0); usually it is manual, it is automatic if you plan on placing multiple plates which are in the same sequence.
+  The advanced option dialog allows you to determine whether collision control is on (1) or off (0). The error settings dialog allows you to program in automatic responses to specific errors. 
+
+.. ven:function:: iSWAP Move Plate (Single Step)
+
+  The iSWAP Move Plate (Single Step) function allows the iSWAP to move to a specified location. You input the target sequence which is the location you wish the iSWAP to be moved to. The advanced option dialog allows you to determine whether the labware is gripped on the small side (0) or long side (1), as well as whether collision control is on (1) or off (0). The error settings dialog allows you to program in automatic responses to specific errors. 
+
+.. ven:function:: iSWAP Open Gripper (Single Step)
+
+  The iSWAP Open Gripper (Single Step) function allows the iSWAP to open the gripper and release the plate without placing it down; usually to drop it into the operator's hands or to drop the plate from a slight height onto the carrier with the intention of causing the liquid inside it to be disturbed by the motion. You can control whether the transport mode is for the plate only (0), the lid only (1), or the plate and lid together (2). You also pick the plate sequence, and can pick the lid sequence if relevant. You can determine whether sequence counting is manual (0) or automatic (1); unless you are doing it to multiple plates then sequence counting should be manual. You can specify whether the labware is gripped on the small side (0) or the long side (1), as well as whether or not to overwrite the grip data from the labware definition. If you do, then you specify the grip opening width. The error settings dialog allows you to program in automatic responses to specific errors.
+
+.. ven:function:: iSWAP Close Gripper (Single Step)
+
+  The iSWAP Close Gripper (Single Step) function allows the iSWAP to close the gripper and hold the plate without picking it up. You can control whether the transport mode is for the plate only (0), the lid only (1), or the plate and lid together (2). You also pick the plate sequence, and can pick the lid sequence if relevant. You can determine whether sequence counting is manual (0) or automatic (1); unless you are doing it to multiple plates then sequence counting should be manual. You specify the grip height of the labware, which is the number of mm that the iSWAP is gripping below the top of the labware. By default it is 3mm. You can specify whether the labware is gripped on the small side (0) or the long side (1), as well as whether or not to overwrite the grip data from the labware definition. If you do, then you specify the grip opening width. The advanced dialog option allows you to specify the grip force being used on a scale of 0 to 10, with 0 being low and 10 being high. The default is 5. In the advanced dialog you also specify the grip tolerance in mm. The error settings dialog allows you to program in automatic responses to specific errors.
+
+.. ven:function:: iSWAP Get First Plate Position (Single Step)
+
+  The documentation for this function has not yet been written.
+
+.. ven:function:: Wait for TADM Upload (Single Step)
+
+  The Wait for TADM Upload (Single Step) function forces the method to wait until the TADM data for specified pipetting tool (either the 1000ul channels (0), the 5ml channels (1), or the 96 head (2)) has been uploaded to a microsoft access database. 
+
+Microlab STAR Smart Steps
+-------------------------------------------------