MethodSCRIPT v1.5

MethodSCRIPTs are sent to the device using the communication protocol, which is described in detail in a separate document. Since there is a tight relationship between the two protocols, a brief summary and example are given below.

To send a script to the device:

The e and l command, as well as the empty line, are not part of the MethodSCRIPT language but are part of the device communication protocol.

The following example shows how the above MethodSCRIPT can be transmitted and executed using the device communication protocol. In this example, the newline characters are rendered as \n.

The response of above script will be:

This response can be broken down into three parts:

In the remainder of this document, only the MethodSCRIPT commands will be shown, without the e or l command, and without the empty line at the end. For readability, the \n will be omitted as well, except when needed for clarification.

MethodSCRIPT variables represent numerical values that can be used within the script. They can be stored internally either in floating-point format or as signed integer. Some commands only accept integer variables, others will only accept floating-point variables (floats). In Chapter 14, Script command description, the arguments of each command are documented. See the "Arguments" table in each command section.

Floating-point variables are represented as a signed integer value followed by an SI prefix. See Table 1, “SI prefix conversion table” for the available SI prefixes. Only SI prefixes available in this table can be used. For example, a variable with a value of 100 and a prefix of m translates to a floating point value of 0.1 (= 100×10^-3).

Integer variables end with an i instead of an SI prefix. If no prefix is provided, the number is assumed to be a floating-point number. Integer variables can also be entered in hexadecimal or binary representation by prefixing the value with 0x or 0b respectively. In this case, the i at the end of the number is optional. Hexadecimal and binary representations are not allowed for floating-point variables.

Variables are not explicitly linked to a unit; instead the unit is implied by the associated Variable Type. Refer to section Chapter 7, Variable types for more information.

Some number input parameters are not MethodSCRIPT variables. These include uint8, uint16 and uint32. For such integer parameters, it is allowed but not necessary to append an i. They do not accept SI prefixes.

Variables that are part of the MethodSCRIPT are represented as a signed integer followed by a prefix for floating-point values, or i for integer values.

Above example shows the integer value of the decimal number 255 using decimal, hexadecimal and binary representation. In the example, the i is omitted in places where it is optional.

Above example shows the floating-point number 0.5. It is stored internally as a floating-point number because it has an SI prefix.

Variables that are part of a measurement data package are represented as 28-bit unsigned hexadecimal values with an offset of 0x8000000 (= 2²⁷). A floating-point variable has one of the SI prefixes shown in Table 1, “SI prefix conversion table”, an integer variable ends with an i instead.

This format looks as follows:

Where HHHHHHH is the hexadecimal value and p is the prefix character .

For example, a value of 0.01 would be represented as 800000Am and a value of -0.01 would be represented as 7FFFFF6m. PalmSens provides source code examples that showcase how to parse measurement data.

To convert a MethodSCRIPT variable to a floating-point value, the following pseudocode can be used:

To convert a floating-point value to a MethodSCRIPT variable, the following pseudocode can be used:

Most programming languages have a built-in way of converting a HEX string to an integer. The function SIFactorFromPrefix can be implemented by the user using, for example, a lookup table or a switch case to translate the prefix character to its corresponding factor. Example implementations for several programming languages and platforms can be found on our MethodSCRIPT Examples repository on GitHub.

Measurement packages consist of a header, followed by up to 33 variable packages (each with their own variable type), followed by a terminating \n character. Consecutive packages are separated using a semicolon. The package format is shown in Table 2, “Measurement data package format.”. Section 5.2, “Variable sub package format” explains the format of the variable fields.

The format for a variable sub package is:

Where:

Metadata fields contain extra information about the variable. Each variable can have multiple metadata fields. See Table 4, “Metadata types.” for the possible metadata types.

A MethodSCRIPT device sends the following measurement data package:

This package contains two variables: da8000800u and ba8000800u,10,20B.

The variable sub package da8000800u can be broken down as follows:

The variable sub package ba8000800u,10,20B can be broken down as follows:

Most measurement techniques are implemented as measurement loop commands. This means that the command will execute one iteration of the measurement technique. After this, all MethodSCRIPT commands within the measurement loop are executed. When all commands have been executed, the device waits for the correct timing to start the next iteration of the measurement technique and the process begins again for the next iteration.

If the user code takes more time than there is available, the next iteration is started too late, which likely results in less accurate measurement results. This will be reflected in the metadata (see Table 4, “Metadata types.”), by setting the "timing not met" status flag, so it can be detected by inspecting the metadata. How much time is available for user code depends on many factors and should be determined empirically. For very fast measurement iterations it is recommended to keep the code inside the loop as short as possible so it does not take too long.

Limitation:
It is not possible to use a fast technique or another measurement loop inside of a measurement loop. However, measurement loops can be used freely inside of a normal loop and vice versa.

Below is an example of a MethodSCRIPT containing a measurement loop. This works as follows:

The start of a measurement loop is always indicated by a line in the format MXXXX where XXXX is the technique ID of the measurement loop (see Table 5). The end of a measurement loop is indicated by a line containing only an asterisk (*). In general, the output of a measurement loop would like something like this:

When the above example script is executed, the output could look like this.

As explained in Chapter 5, Interpreting measurement data packages, daDF5CB18n denotes a variable of type CELL_SET_POTENTIAL (i.e. the Set control value for WE potential) with a value of 0.099994392 [V]. Due to the resolution of the DAC, the actual value is very close, but not exactly equal, to the specified value of 100 mV. The actual used value is returned by the measurement loop commands so they can be used in futher calculations.

The argument var is a reference to a MethodSCRIPT variable. Variables can be changed during runtime. Before a variable can be used, it first has to be declared to tell the instrument to reserve some memory. This can be done using the var command (see Section 14.1, “var”). Variable names must start with a lower case letter ('a' - 'z') and can for the rest consist of more lower case letters, numbers or underscores '_'.

For example, this allocates a few variables:

The variable names are translated in the parsing stage so that their length or the amount of variables does not affect runtime. When choosing variable names, take the following into account: - The parser can only remember ~250 characters for all variable names combined - Lines have limited length (see communication protocol document), this can be important for commands with multiple parameters.

There can only be at most 26 variables. Variables are preserved during hibernation and exist for the duration of the script.

For storing more than one element, arrays can be used. This can be used with for example I²C data, fast techniques or generic measurements. Like variables, arrays have to be defined before they can be used (see Section 14.3, “array”). Interaction with arrays happens via their reference (just like variables). Arrays and variables denote distinct types, and cannot generally be substituted for one another in command arguments.

An example of defining an array, filling it with (squared) numbers and printing the content:

A literal is a constant value argument, it cannot change during runtime.

See Chapter 7, Variable types.

These are integer constants, these cannot be changed and do not accept SI prefixes. Minimum and maximum values for these variables are as follows:

Condition expressions are used in the MethodSCRIPT commands if, elseif and loop. A condition expression always consists of an operator with two operands, in the form operand1 operator operand2, for example i < 10. The operators and operands must be separated by at least one space or tab. Both operands can be either a MethodSCRIPT variable or an (integer or floating-point) literal. The following operators are supported:

Notes:

A sequence of characters, i.e. a piece of text. Strings are enclosed in double quotes, e.g. "example string". Strings may only consist of printable ASCII characters (ASCII code 32–126), excluding the quotation mark ("), since that is used as delimiter.

In MethodSCRIPT, strings are always literals (constants). There are no commands to store or modify strings.

Some commands can have optional arguments to extend their functionality. For example most techniques support the use of a second working electrode (bipot or poly_we). See Chapter 9, Optional arguments for detailed information.

Measure a current on a secondary WE. This secondary WE uses the CE and RE of the main WE, but can be offset in potential from the main WE or RE. WE’s that are used as poly WE must be configured as such using the command set_pgstat_mode 5 for the channel the WE belongs to.

The following code example performs an LSV measurement and sends a data packet for every iteration. The data packet contains the set potential (p), the measured current of the main WE (c) and the measured current of the secondary WE (b). The LSV performs a potential scan from -500 mV to +500 mV with steps of 10 mV at a rate of 100 mV/s. This results in a total of 101 data points at a rate of 10 points per second.

Perform multiple potential sweeps (scans) during a Cyclic Voltammetry measurement, instead of sweeping only once. When nscans is used, the cycle number will be printed at the start of every sweep. The number is formatted as Cnnnn where nnnn is an integer ranging from 0000 to 9999. A special character (-) is printed at the end of every cycle. For the rest the output is the same as when nscans omitted. See output example below.

This example CV performs a potential scan from 0 V to -500 mV to 500 mV and back to 0 V with steps of 10 mV at a rate of 1 V/s. Because of the nscans(2) parameter, this pattern is repeated two times.

Output for example with nscans 2

Average the measured currents of multiple scans in a Cyclic Voltammetry measurement, keeping the same array length as when having only one scan.

For example, the following meas_fast_cv command will perform 7 scans which are averaged together. The result is stored in arrays p and i and printed using a loop.

The output contains 5 points, just like a scan without averaging would. In contrast with a regular scan without nscans_avg, the currents are averages over 7 scans.

Perform n amount of scans without measuring current, before the normal measured scans.

The following example illustrates the use of nscans_equil performing 3 equilibration scans. Output format is the same as without this optional parameter.

Enable or disable metadata packages sent with the pck_add command. This can be used to reduce the amount of data sent by disabling packages, making it possible to achieve higher data rates.

This example measures a current and then sends two packages containing the measured current. The first package will include the current range and status metadata. The second package will only include the status metadata.

The eis_tdd optional parameter enables the transfer of time-domain data (TDD) for an EIS, GEIS, or MSEIS measurement.

The following example performs an EIS measurement and sends the EIS result data packets followed by the time-domain data for every iteration.

The eis_opt optional parameter enables the user to control the acquisition properties for an EIS or GEIS measurement.

This example performs an EIS measurement with 10 ms minimal acquisition time and minimal 1 cycle to acquire.

The eis_acdc optional parameter returns the AC and DC information for the potential and current signal.

Perform an EIS measurement and send the EIS result data packets followed by the E_AC, E_DC, I_AC, I_DC values.

The ms_eis_acdc optional parameter returns the AC and DC information for the E and I signal of a MSEIS measurement. The user should make sure that the E_AC and I_AC argument are an array of sufficient length.

Perform an MSEIS measurement and send the MSEIS result data packets followed by the E_AC and I_AC arrays, and finally the E_DC and I_DC values.

The commands after this this tag will be executed when the script is aborted, or when normal script execution reaches the tag. A script can be aborted either by the MethodSCRIPT abort command, or by the abort (Z) command from the communication protocol. Note that the commands after the on_finished: tag are not executed if a script error has occurred, as no further commands are executed in this case.

The following example demonstrates the program flow when using abort and on_finished: in a script:

Output:

The following scripts illustrates the use of the on_finished: tag in a more realistic use case. In this example, the cell will be switched off when the EIS loop is finished or when the script is aborted during the EIS loop.

All measurement hardware is turned off to save power, no measurements can be done.

The hardware configuration that has the best properties for low speed measurements is picked. Usually this means it is less sensitive to high frequency noise and consumes less power. However the maximum bandwidth is limited.

The hardware configuration that has the best properties for high speed measurements is used. In general, this will consume more power and be more sensitive to noise. However, it will allow higher frequency measurements to be done.

This mode uses a hardware configuration having the highest possible potential range by combining the high and low speed mode In general, this will consume more power and be more sensitive to noise The bandwidth is limited to the bandwidth of the low speed mode.

This mode sets the channel up to be used as an extra WE electrode that applies a potential relative to the WE of the main channel. This is also known as a bipot or a poly WE. This mode uses the RE and CE of the main channel, and does not use the RE and CE of the poly WE channel.

This mode is used to control the applied current, rather than the applied potential. This mode is required for all galvanostatic techniques and commands.

The following table lists all MethodSCRIPT commands, in which version they are introduced and which instruments are supported. In chapter Chapter 14, Script command description these commands are described in detail.

The below table lists the relationship between the instrument’s firmware version and the MethodSCRIPT version.

Declare a variable. All MethodSCRIPT variables must be declared before use. When a variable is declared, it is initialized with the floating-point value 0 and VarType aa. For details on naming and limitations see Chapter 8, Script argument types.

Define two variables with names foo and bar

Store a value in a variable.

Store the value 200 as a floating-point number in the variable foo, with VarType VT_MISC_GENERIC1 (ja).

Same as above, but now as an integer value instead of floating-point value.

Declare an array. Arrays can store multiple variables. All arrays must be declared before use. The name may not be used by another array or variable. For details on naming and limitations see Chapter 8, Script argument types.

Arrays have a fixed size and their memory is allocated when the command is first run. The minimum size is 1 and the maximum size is determined by the available memory on the device (see Table 6, “Total storage for array elements”). If there is not enough memory available, an error is generated.

It is allowed to declare the same array multiple times (with the same name). This makes it possible to declare an array inside a loop. However, when a variable is declared multiple times, the size must be the same, otherwise an error is generated. When redeclaring an array, the memory is reused.

Note that array memory is not freed until the end of the MethodSCRIPT, so it is best to avoid declaring many large arrays.

When this command is executed, all values in the array are initialized with the floating-point number 0.

Arrays are necessary for some MethodSCRIPT commands, but can also be used in general to store multiple variables, for example inside loops. Values can be written using array_set and read using array_get. Arrays use zero-based indexing, so the first element has index 0, the second element has index 1, and so on.

Declare array with name foo_bar_baz and size 10.

Set a variable at the specified array index.

The following example declares an array foobar with 6 elements, and writes the value 0.02 to the last element (the variable at index 5).

To set the VarType as well, first define another variable, then store that variable in the array. The following example is similar to the example above, but also sets the VarType to ja.

Get a variable from the specified array index.

Get the value in the array at index 5 and store it in variable b.

Copy a variable. Copying includes the value, VarType and any metadata stored in a variable.

Copies the variable x to y.

Add a value to a variable.

The value of arg2 is added to the variable specified by arg1. Both arguments must have the same data type (both int or both float). The VarType and metadata of the variable(s) are not changed.

Add 1 to variable x and store the result in x.

Subtract a value from a variable.

The value of arg2 is subtracted from the variable specified by arg1. Both arguments must have the same data type (both int or both float). The VarType and metadata of the variable(s) are not changed.

Subtract 1 from the variable x and store the result in x.

Multiply a variable.

The value of arg1 is multiplied with the value of arg2. Both arguments must have the same data type (both int or both float). The VarType and metadata of the variable(s) are not changed.

Multiply the variable x with 1.5 and stores the result in x.

Divide a variable.

The value of arg1 is divided by the value of arg2. Both arguments must have the same data type (both int or both float). The VarType and metadata of the variable(s) are not changed.

Divide the variable x by 1.5 and stores the result in x.

Perform a modulo operation on a variable.

Calculate the remainder of dividing arg1 by arg2 and store the result in arg1. Both arguments must be integer variables. The VarType and metadata of the variable(s) are not changed.

Calculate the remainder of dividing the variable a by 4 and store the result in a.

Perform a bitwise AND operation.

The value of arg2 is bitwise ANDed to the variable specified by arg1. The VarType and metadata of the variable(s) are not changed.

Perform a bitwise AND operation on t and 0x5555 and store it to t.

Perform a bitwise OR operation.

The value of arg2 is bitwise ORed to the variable specified by arg1. The VarType and metadata of the variable(s) are not changed.

Perform a bitwise OR operation on t and 0x5555 and store it to t.

Perform a bitwise XOR operation

The value of arg2 is bitwise XORed to the variable specified by arg1. The VarType and metadata of the variable(s) are not changed.

Perform a bitwise XOR operation on t and 0x5555 and store it to t.

Logical Shift Left variable.

Shift the variable specified by the first argument to the left by the number of bit positions specified in the second argument. The VarType and metadata of the variable(s) are not changed.

Perform a bitwise shift 4 places to the left on t and store it to t.

Logical Shift Right variable.

Shift the variable specified by the first argument to the right by the number of bit positions specified in the second argument. The VarType and metadata of the variable(s) are not changed.

Perform a bitwise shift 4 places to the right on t and store it to t.

Bitwise invert a variable.

Perform a bitwise inverse operation on t.

Change the data type from int to float. Because of the nature of floats, this command will round to the nearest value. The VarType and metadata of the variable(s) are not changed.

Convert variable a to float.

Change the data type from float to int. When changing the data type from floating-point to integer, the fractional part is discarded, i.e., the value is truncated towards zero. If the value is outside the range of an int32 variable, the result is undefined. The VarType and metadata of the variable(s) are not changed.

Convert variable a to int.

Apply a variable or literal as the WE potential. The potential is limited by the potential range of the currently active PGStat Mode see Section B.1, “PGStat mode properties”.

Set WE potential to 0.1 V.

Apply a variable or literal as the WE current in galvanostatic mode. Applied currents are limited by the selected CR. It is advised to use the set_range command before calling set_i.

Sets control current value for the galvanostat loop to 0.1 A.

Wait for the specified amount of time.

Wait 100 milliseconds.

Configure the interval for the await_int command. This also (re)starts the counter for the interval timer.

Set interval to 100 milliseconds.

Wait for the next interval. This command allows the use of an asynchronous background timer to synchronize the script to a certain interval.

-

Set interval to 100 ms. Then execute a loop every 100 ms using await_int to synchronize the start of each loop. Even though the loop takes a variable amount of time because of the variable wait command, the loop will execute once every 100 ms.

Repeat a block of commands while some condition is fullfilled.

Each time the loop command is executed, the condition expression is evaluated. If the result is true, the commands between the loop and the corresponding endloop command are executed. The endloop command then jumps back to the loop command. If the result of the expression is false, the script continues after the corresponding endloop command.

For every loop command, there must be exactly one matching endloop command.

Add 1 to variable i until it reaches the value 10.

Note that the code between the loop and endloop commands is indented for readability, but this is not required. As described in Chapter 3, Script format, whitespace at the start of the line is ignored.

Signal the end of a loop.

This command is used to end a loop command or any of the measurement loop commands. See the corresponding commands for more details.

-

Break out of the current loop. The script will continue execution after the next endloop.

-

Conditional statements allow the conditional execution of commands. Every if statement must be terminated by an endif statement. In between the if and endif statements can be any number of elseif statements and/or one else statement. Accepts either integer or floating-point variables, but if argument types don’t match, they are compared as floats.

One of the send_string commands will be executed, depending on the value of variable a.

Measure a data point of the specified type and store the result as a variable. The data point will be averaged for the specified amount of time at the maximum available sampling rate.

For supported value types of each device, refer to Section B.5, “Supported variable types for meas command”.

Measure the signal with the VarType ba (VT_CURRENT) for 100 ms and store the result in the variable c.

Perform a Linear Sweep Voltammetry (LSV) measurement. An LSV measurement scans a potential range in small steps and measures the current at each step. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for information about measurement loops in general.

The following optional arguments are supported:

Perform an LSV measurement and send a data packet for every iteration. The data packet contains the set potential and measured current. The LSV performs a potential sweep from -500 mV to 500 mV with steps of 10 mV at a rate of 100 mV/s. This results in a total of 101 data points at a rate of 10 points per second.

Perform a AC Voltammetry (ACV) measurement. In a ACV measurement, a potentialscan is performed with a superimposed sine wave. At each step, the ac-potential and ac-current are measured and the complex impedance is calculated.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information.

Perform an ACV measurement and send a data packet for every iteration, with each packet containing the set potential and AC current.

The ACV performs a potential scan from -500 mV to 500 mV with steps of 10 mV, a scanrate of 20 mV/s and an amplitude of 10 mV at 15 Hz. This results in a total of 101 data points at a rate of 2 points per second.

Perform a Linear Sweep Potentiometry (LSP) measurement. An LSP measurement scans a range of currents in small steps and measures the potential at each step. Galvanostatic PGStat mode (6) is required for LSP. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

Perform an LSP measurement and send a data packet for every iteration. The data packet contains the set current and measured potential. The LSP performs a current sweep from -5 mA to 5 mA with steps of 100 µA at a rate of 1 mA/s. This results in a total of 101 data points at a rate of 10 points per second.

Perform a Cyclic Voltammetry (CV) measurement. In a CV measurement, the potential is stepped from the begin potential to the vertex 1 potential, then the direction is reversed and the potential is stepped to the vertex 2 potential and finally the direction is reversed again and the potential is stepped back to the begin potential. The current is measured at each step. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform a CV measurement and send a data packet for every iteration. The data packet contains the set potential and measured current. The CV performs a potential scan from 0 mV to 500 mV to -500 mV to 0 mV. It steps with 10 mV increments at a rate of 100 mV/s. This results in a total of 201 data points at a rate of 10 points per second.

Perform a Fast Cyclic Voltammetry (FCV) measurement. In a CV measurement, the potential is stepped from the begin potential to the vertex 1, vertex 2 and back to the begin potential. For each step, the current is measured. Contrary to the meas_loop_cv function, the Fast CV is not implemented as a measurement loop. That means that the script cannot execute other commands during Fast CV. Measurement data is stored in arrays and can be transmitted afterwards.

For Fast CV, these optional arguments can be combined freely.

nscans defines the number of scans to perform sequentially, the result is stored in the Current array. The first and last measured sample are both measured at the begin potential for symmetry. Splitting the output into multiple scans is quite straightforward. The number of samples per scan is equal to the total number of samples divided by the number of scans.

Currents measured at the last point of one scan are copied and used as first point for the next scan. This is done for convenience and avoids applying the same potential twice in a row.

nscans_equil steps through all vertexes, just like a regular CV scan. The equillibration scans do not measure the current and are intended to prepare the cell before a the first scan.

nscans_avg takes the average of all points over multiple scans while making sure that every potential is set exactly once. This allows averaging more samples to achieve a better signal-to-noise ratio, while still maintaining a low step potential. However, care should be taken that these multiple scans overlap.

The following example performs a Fast CV without optional arguments. It will start at 0 V, go to vertex 1 at 100 mV before going to -100 mV and back to 0 V. The step size is 10 mV and the scan rate is 1 V/s.

The following example performs a Fast CV with nscans argument to perform 5 scans sequentially.

The following example illustrates Fast CV with nscans_equil argument to perform 2 scans before actual measurements. After the 2 equilibration scans, a single Fast CV scan is performed.

The following example performs a Fast CV with nscans_avg argument to perform averaging over 3 scans. The format of p,i and c variables is the same as if nscans_avg was not performed even though the values are averaged.

The following example performs a Fast CV with all 3 optional arguments. After equillibrating for 1 scan, 3 scans are performed which are averaged twice each.

Perform a Differential Pulse Voltammetry (DPV) measurement. In a DPV measurement, the potential is stepped from the begin potential to the end potential. At each step, the current (reverse current) is measured, then a potential pulse is applied and the current (forward current) is measured. The forward current minus the reverse current is stored in the "Measured current" variable. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform a DPV measurement and send a data packet for every iteration. The data packet contains the set potential and "forward current – reverse current". The DPV performs a potential scan from -500 mV to 500 mV with steps of 10 mV at a rate of 100 mV/s. This results in a total of 101 data points at a rate of 10 points per second. At every step a pulse of 20 mV is applied for 5 ms.

Perform a Square Wave Voltammetry (SWV) measurement. In a SWV measurement, the potential is stepped from the begin potential to the end potential. At each step, the current (reverse current) is measured, then a potential pulse is applied and the current (forward current) is measured. The forward current minus the reverse current is stored in the "Measured current" variable. The pulse length is "1 / Frequency / 2". A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform a SWV measurement and send a data packet for every iteration. The data packet contains the set potential and "forward current – reverse current". The SWV performs a potential scan from -500 mV to 500 mV with steps of 10 mV at a frequency of 10 Hz. This results in a total of 101 data points at a rate of 10 points per second. At every step a pulse of 30 mV (2 * 15 mV) is applied for 50 ms (1/Frequency/2).

Perform a Normal Pulse Voltammetry (NPV) measurement. In an NPV measurement, the pulse potential is stepped from the begin potential to the end potential. At each step the pulse potential is applied and the current is measured at the top of this pulse. The potential is then set back to the begin potential until the next step. The measured current is stored in the "Output current" variable. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform an NPV measurement and send a data packet for every iteration. The data packet contains the set potential and measured pulse current. The NPV performs a potential scan from -500 mV to 500 mV with steps of 10 mV at a rate of 100 mV/s. This results in a total of 101 data points at a rate of 10 points per second. At every step a potential pulse of "step index * step potential" mV is applied for 5ms.

Perform a Chronoamperometry (CA) measurement. In a CA measurement, a DC potential is applied and the current is measured at the specified interval. The measured current is stored in the "Output current" variable. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform a CA measurement and send a data packet for every iteration. The data packet contains the set potential and measured current. A DC potential of 100 mV is applied. The current is measured every 100 ms for a total of 2 seconds. This results in a total of 20 data points at a rate of 10 points per second.

Perform a Chronoamperometry (CA) measurement in alternating multiplexer mode. In a CA measurement, a DC potential is applied and the current is measured at the specified interval. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

During the interval time, all selected multiplexer channels are measured for an equal amount of time. The measured current is stored in the "Output current" array. This array should be large enough to hold all sampled multiplexer channels. Before this alternating multiplexer command can be used, the multiplexer has to be configured using mux_config.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following example performs a CA measurement on multiplexer channels 1 to 3. Apply a potential of 1 V, use an interval of 300 ms, and run for 9 seconds.

Perform a Fast Chronoamperometry (FCA) measurement.

This command is similar to the meas_loop_ca command, which is a measurement loop command. However, the fast measurement command is intended for short, (very) fast measurements with an accurate timing. The maximum data rate is 1 MS/s (1 million samples per second), using an interval time of 1 µs. Measurement points are averaged at maximum sample rate during the interval time, if possible. To achieve this, no other MethodSCRIPT commands can be performed during the measurement, and the results must be stored in an array. As a consequence, the number of data points to measure is limited to the maximum size of an array (50,000 on the EmStat4).

The set_acquisition_frac command does not apply for Fast CA measurements. Measurements are performed over the entire interval time.

The following example performs a Fast CA measurement of 1 ms with an interval time of 1 µs and an applied potential of 200 mV.

A more comprehensive example can be found in Section 15.5, “Fast CA example”.

Perform a Chronopotentiometry (CP) measurement. In a CP measurement, a DC current is applied and the potential is measured at the specified interval. The measured potential is stored in the "Output potential" variable. Galvanostatic PGStat mode (6) is required for CP. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

Perform a CP measurement and send a data packet for every iteration. The data packet contains the measured potential and set current. A DC current of 1 mA is applied. The potential is measured every 100 ms for a total of 2 seconds. This results in a total of 20 data points at a rate of 10 points per second.

Perform a Chronopotentiometry (CP) measurement in alternating multiplexer mode. In a CP measurement, a DC current is applied and the potential is measured at the specified interval. Galvanostatic PGStat mode (6) is required for CP. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

During the interval time, all selected multiplexer channels are measured for an equal amount of time. The measured potential is stored in the "Output potential" array. This array should be large enough to hold all sampled multiplexer channels. Before this alternating multiplexer command can be used, the multiplexer has to be configured using mux_config.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following example performs a CP measurement on multiplexer channels 1 to 3. Apply a current of 1 uA, use an interval of 300 ms, and run for 9 seconds.

Perform a Pulsed Amperometric Detection (PAD) measurement. In a PAD measurement, potential pulses are periodically applied. Each iteration starts at the DC potential, the current is measured before the pulse (i_dc). Then the pulse potential is applied, and the current is measured at the end of the pulse (i_pulse). The output current returns a current value depending of one the 3 modes: dc (i_dc), pulse (i_pulse) or differential (i_pulse – i_dc). A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform a PAD measurement and send a data packet for every iteration. The data packet contains the set potential and measured current. A DC potential of 500 mV is applied. A pulse potential of 1500mV is applied every 50 ms for 10 ms and the current is measured on the pulse (mode = pulse). The measurement is 10,05 seconds in total. This results in a total of 201 data points at a rate of 20 points per second.

Perform an Open Circuit Potentiometry (OCP) measurement. In an OCP measurement, the CE is disconnected so that no potential is applied. Therefore, the cell needs to be turned off (using the cell_off command) before starting this measurement. The open circuit RE potential is measured at the specified interval. The measured potential is stored in the "Output potential" variable. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

Perform an OCP measurement and send a data packet for every iteration. The data packet contains the measured RE potential. The RE potential is measured every 100 ms for a total of 2 seconds. This results in a total of 20 data points at a rate of 10 points per second.

Perform an Open Circuit Potentiometry (OCP) measurement in alternating multiplexer mode. In an OCP measurement, the CE is disconnected so that no potential is applied. Therefore, the cell needs to be turned off (using the cell_off command) before starting this measurement. A more detailed explanation on this technique can be found on the PalmSens knowledge base.

During the interval time, all selected multiplexer channels are measured for an equal amount of time. The measured potential is stored in the "Output potential" array. This array should be large enough to hold all sampled multiplexer channels. Before this alternating multiplexer command can be used, the multiplexer has to be configured using mux_config.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following example performs an OCP measurement on multiplexer channels 1 to 3. Use an interval of 300 ms, and run for 9 seconds.

Perform a (potentiostatic) Electrochemical Impedance Spectroscopy (EIS) measurement.

Perform a frequency scan and store the resulting Z-real and Z-imaginary in the given variables. High speed potentiostatic PGStat mode is required for EIS. The following commands currently have no effect on EIS measurements:

A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform an EIS frequency scan from 100 kHz to 100 Hz with 10 mV amplitude and 200 mV DC offset. The frequency for each iteration is returned in variable f. The measured complex impedance is returned in 2 variables with Z-real in r and Z-imaginary in i. In total, 11 points will be measured at frequencies between 100 kHz and 100 Hz, divided on a logarithmic scale.

Perform a Galvanostatic Electrochemical Impedance Spectroscopy (GEIS) measurement.

Perform a frequency scan and store the resulting Z-real and Z-imaginary in the given variables. Galvanostatic PGStat mode (6) is required for GEIS. The following commands currently have no effect on GEIS measurements:

A more detailed explanation on this technique can be found on the PalmSens knowledge base.

This is a measurement loop function and needs to be terminated with an endloop command. Refer to Chapter 6, Measurement loop commands for more information about measurement loops in general.

The following optional arguments are supported:

Perform an GEIS measurement at frequency f with 10 mA_rms amplitude and 25mA DC offset. The measured complex impedance is returned in 2 variables with Z-real in r and Z-imaginary in i. In total, 11 points will be measured at frequencies between 100 kHz and 100 Hz, divided on a logarithmic scale.

Perform a Multi-Sine EIS (MSEIS) measurement.

Multi-Sine EIS (MSEIS) can measure an impedance spectrum in less time then EIS at the cost of a reduced Signal-to-Noise Ratio (SNR). This command performs a potentiostatic multi-sine EIS measurement and stores the resulting frequencies, Z-real, and Z-imaginary in the given arrays.

The following commands currently have no effect on MSEIS measurements:

Depending on the expected impedance curve, a perturbation-preset can be chosen. A total of 6 presets are available with varying harmonics and amplitude distributions. Presets 1, 2, 4 and 5 feature a logarithmically decaying amplitude distribution, meaning that the base frequency has a relative amplitude of 1, and the highest included harmonic has a relative amplitude as specified in the table. The decrease of amplitude follows a logarithmic distribution, and can be benificial when the cell shows capacitive behavior.

Perform a MSEIS measurement using multisine preset 3 with 10 mV peak amplitude and 180 mV DC offset. The harmonic frequencies and complex impedances are stored in the arrays freqs, reals and imags. The user must ensure the supplied arrays are long enough to store the results of the chosen preset. When the measurement is done, the data is sent back point by point in a loop.

Configure the autoranging for all meas_loop_* functions. Autoranging selects the most appropriate range for the measured value in the last measurement loop iteration. The selected range is limited by the min and max arguments. If min and max are the same value, autoranging is disabled.

Enable autoranging for currents between 1 µA and 1 mA.