CETONI Elements now supports precision scales!

Integration of a high-resolution precision balance in your application offers you precise information at every point in your process and thus additional security. With the help of our flexible laboratory automation software CETONI Elements You can now integrate precision scales into your process and use them for targeted control of your high-precision dosing, automation of processes or permanent process monitoring.

Simply install the latest QmixElements update and getting started!

The CETONI Elements software now supports the integration of laboratory balances via the balance plug-in. A device driver for Sartorius scales (Entris, ED, GK and GW scales) is already included with the release of the plugin. This means that you can easily integrate your existing Sartorius laboratory balance into the CETONI Elements software. Thus you not only extend your CETONI system with the possibility to weigh substances, substances or dosed liquids, but you can also synchronise or completely automate processes as you wish in interaction with other CETONI hardware and your own analysis.

CETONI Elements with two Nemesys syringe pumps and a scale

The configuration of the scale devices is carried out, as you are used to from the CETONI Elements software, via the device configurator. Simply create a new configuration or add the scale to an existing configuration and save it. After activating the configuration, the scale is available in the software.

Elements Device Configurator

In the software, the scale is then displayed as a normal analogue input channel in the list of I/O channels ❶. There you can see the current value at any time and tare the scale via the context menu of the channel. Like all other analogue channels, you can also record this channel in the graphic logger ❷ or in the CSV logger and use it to create control channels. Due to the real-time recording of the measured value in the graphic logger, dynamic weight changes, e.g. when dosing into a sample vessel, can be visualised and followed very well.

List of I/O channels with scale channel

The measuring channel of the scale can be read via the script system and taring of the scale is also possible via a script function. This allows the scale to be easily integrated into more complex analyses and automated processes.

In the second part of this tutorial you will learn how to create sinusoidal flow profiles using JavaScript functions. To do this, you modify the script from the first part so that a sinusoidal profile is generated instead of a sawtooth profile. Before you start with this second part, you may want to read the first part of the tutorial here.

Important
For this tutorial, you need QmixElements version v20191121 or a newer version. If you are still using an older version, please update to the latest QmixElements version.

Latest QmixElements Version

Preparation

Configure your system as described in the first part of the tutorial and then connect to your devices. If you do not have the appropriate devices, you are welcome to follow the tutorial with simulated devices. The QmixElements project with simulated devices and the script created in the first tutorial can be downloaded here.

Now open the script Tutorial_Sawtooth_Profile.qsc that you created in the first part of the tutorial and save it under a new name. You should then see the following program in script editor.

Part 2 – Script for generating a sinusoidal profile

The goal of this script is to generate a flow profile in the form of a sine wave from 0 to the defined target flow rate with one pump and to supplement the flow of the first pump with the second pump in such a way that the sum of the two flows results in a constant flow with a defined flow rate.

To generate the profile, the flow rate of the pump must be changed step by step so that a sinusoidal profile is created over time. The number of steps for generating the sine profile, i.e. the resolution, should be set to 100 steps for one sine. In the previous sawtooth script you had set the number of steps to 20. Therefore change the value of the variable $GradientSteps to 100.

Adjusting the resolution (number of steps) for a sine profile

Now delete the two Generate Flow functions as shown in the figure below. To do this, select both functions and then delete them using the context menu (right mouse button) or by pressing the Delete key.

Now insert a new variable before the two existing variables in the counting loop. Name the variable $Sinus and select JavaScript Expression in the Type field.

The $Sine variable is used to store the calculation of the sine value for further processing. To calculate the sine value, use the JavaScript function Math.sin() together with the constant Math.PI. Enter the following into the input field for the JavaScript expression:

Math.sin(2 * Math.PI / ($GradientSteps – 1) * $i)

The loop counter $i runs from 0 to the number of $GradientSteps – 1. To calculate the current sine value, the period 2π is divided by the number of steps – 1 and then multiplied by the current step $i.

To check the calculated value of the $Sine variable, you can display its value in the graphical logger. To do this, you have already created the virtual I/O channel Script Value 1 in the first part of the tutorial and added it to the graphical logger. Now insert the function Write Device Property ❶ into the script. Then configure the function as shown in the figure below.

In the field Value to be written ❷ enter the variable name $Sinus. In the Device Property area ❸ select in the Devicefield the virtual channel Script Value 1. In the Property field select the property ActualValue. You can now read the function as follows:

Write the value of the variable $Sinus into the property ActualValue of the virtual channel Script Value 1.

Now delete all data from the graphical logger and activate automatic scaling. Now start your script. If you have entered everything correctly, you should see how the following sine function is generated in the graphical logger:

The sine oscillates between 1 and -1 as expected. For the sinusoidal flow profile to be generated, the flow rate should oscillate between 0 and the target flow rate. In a first step, the sine value should be adjusted so that it oscillates between 0 and 1. You can achieve this by shifting the sine on the Y-axis upwards by 1 and then halve the amplitude. To store the new value, we use the existing variable $Flow1 ❶. This can now be calculated like this:

❷ $Flow1 = ($Sine + 1) / 2

Now change the Write Device Property function so that the value of the variable $Flow1 is displayed instead of the value of the variable $Sine. Then delete the graphical logger and reactivate automatic scaling. You should now see the following function in the graphic logger – a sine function oscillating between 0 and 1:

To make the sine oscillate between 0 and the target flow rate, you now only have to multiply by the target flow rate $TargetFlow. Extend the calculation of the variable $Flow1 by this step:

$Flow1 = ($Sine + 1) / 2 * $TargetFlow

The flow rate $Flow1 will now oscillate sinusoidally between 0 and the target flow rate. The flow rate $Flow2 of the second pump should complement the first flow rate in such a way that a constant flow with a constant flow rate $TargetFlow is created. You can therefore calculate the flow rate of the second pump in the variable $Flow2 as follows:

$Flow2 = $TargetFlow – $Flow1

Now insert two Generate Flow functions in front of the Write Device Property function and then delete the Write Device Property function as it is no longer needed.

The script should now look like the figure below ❶. Configure the two Generate Flow functions to start the first pump at flow rate $Flow1 ❷ and the second pump at flow rate $Flow2 (see figure below). Make sure that the Run to completion option ❸ is disabled.

Now delete all data from the graphical logger again and activate automatic scaling. Before starting the script, check that the syringes of both pumps are filled. Then start your script. If you have entered everything correctly, you should see how the following flow profiles are generated in the graphical logger:

You have now learned the basics of how to use JavaScript in the script functions – e.g. to perform mathematical calculations. Apply what you have learned, for example by programming a script that generates two sinusoidal flows, where the sine of the second flow has twice the period of the sine of the first flow. Use the graphical logger to check the results.

In the third part of the tutorial you will learn how to add an initialization routine to the script, how to wind up the syringes and get tips on how to improve the readability of your script and how to document your script.

The QmixElements project with simulated devices and the scripts created in the first and second part of the tutorial can be downloaded here.

The QmixElements software has a powerful script system to automate processes and procedures quickly and easily. This tutorial will give you an insight and many useful hints on some of the advanced features of QmixElements. Techniques, such as the use of variables, the use of JavaScript and the use of virtual channels for recording values in the graphical logger.

In this tutorial, you will create two scripts that generate flow gradients or flow profiles based on mathematical functions.

Preparation

Before you can start programming the scripts, you must configure your system. If you do not have the appropriate devices, you are welcome to follow the tutorial with simulated devices. You can download the QmixElements project with simulated devices and the script created in the tutorial here.

Important
For this tutorial you need the QmixElements version v20191121 or a newer version. If you are still using an older version, please update to the latest QmixElements version.

Latest QmixElements Version

For this tutorial we used two neMESYS low pressure syringe pumps with 5 ml glass syringes ❶. You can do this tutorial with other neMESYS syringe pumps or syringes, but you may have to adjust the flow rates. To switch the valves automatically during the generation of the flow profiles, activate the valve automation for both pumps ❷. Please configure ml/min ❸ as the unit for the flow rate.

To visualize calculated values from the script graphically, create a virtual channel ❹in the list of I/O channels. A virtual channel is an I/O channel that can be used for entering and outputting values.

To record and visualize the generated flow profiles graphically in real time, use the graphical logger and configure it according to the figure below. The current flow rate of both pumps should be displayed as well as the current value of the virtual channel ❶. As Log Interval❷ set a value of 0.1 seconds. Now you can start programming the first script.

Part 1 – Script for generating a sawtooth profile

The aim of this script is to generate a flow profile in the form of a sawtooth with one pump and to supplement the flow of the first pump with the second pump so that the sum of the two flows leads to a constant flow with a defined flow rate but with a mixing ratio that changes over time.

The sawtooth is generated by increasing the flow rate stepwise in a fixed interval from 0 to the desired target flow rate. The following parameters can be identified for the script:

• Number of steps for a single sawtooth ($GradientSteps)
• Duration of a step in milliseconds ($StepDuration)
• Target flow rate ($TargetFlow)

You create three variables for these parameters in your script. So you can change the parameters later quickly and easily in one place, without having to navigate through the complete script all the time. For each variable you assign a meaningful and unique name.

For the gradient, use 20 steps ($GradientSteps = 20) with a duration of 100 milliseconds each ($StepDuration = 100). The resolution of 100 ms is a reasonably fast time base for many applications. You can change these values later at any time. You can enter a fixed value for the target flow rate, or you can calculate the target flow rate based on the maximum flow rate of the first pump. To do this, you can insert the device property (Insert device property) for the maximum flow rate of the pump into the JavaScript field and use it for calculations. In this example we want to dose with one tenth of the maximum flow rate and therefore simply divide it by 10. You can also use other values or your own calculations:

$TargetFlow = $neMESYS_Low_Pressure_1.MaxFlow / 10

To create a single sawtooth, you now need a Counting Loop ❶. Two parameters can be configured for a counting loop: the number of Loop Cycles ❷ and the name of the variable (Counter Variable) in which the counter value for the current loop cycle is stored ❸. The input field for the loop cycles ❷ is marked with an orange V, i.e. you can use variables in this input field. At this point you can simply enter the previously defined variable $GradientSteps.

Within the loop you can now calculate the flow rate for the first pump and save it in a variable. The loop counter $i takes the values 0 – 19 for the 20 loop passes. You can therefore calculate the flow rate with the following formula:

❶ $Flow1 = $TargetFlow / ($GradientSteps – 1) * $i

I.e. the flow rate is 0 in the first loop pass and reaches the value $TargetFlow in the last loop pass. The sum of the flow rates of both pumps should give the value $TargetFlow. Therefore, in a second variable, you can calculate the flow rate of the second pump as follows:

❷ $Flow2 = $TargetFlow – $Flow1

You can now use these two values to start the dosing of the two pumps with the function Generate Flow ❶. To configure the Generate Flow function, simply select the appropriate pump and enter the calculated value $Flow1 or $Flow2 in the Flow field ❷. It is important that the unit for the flow rate is set to the same value as configured for the pump – in this case ml/min ❸. You have to deactivate the Run to completition checkbox ❹. If this field is active, the next function will not be started until the pump has finished dosing. In the case of the Generate Flow function, this would be when the pump is fully wound or drained. Since this is not desired here, but the script is to be continued immediately, deactivate the field.

To achieve the desired step duration for each loop cycle, add a Delayfunction ❶ as the last function in the loop. You can directly enter the variable $StepDuration in the configuration area of the function in the input field Milliseconds ❷. The Delay function delays the further execution of the script for the configured time period.

At the end of your short script, now add the Stop All Pumps ❶ to stop all pumps. To synchronize the recording of the flow rates in the graphical logger with the script flow, add the function to start the logger (Start Plot Logger) ❷ before the counting loop and the function to stop the recording (Stop Plot Logger) ❸ at the end of the script.

When your syringes are completely filled, you can now start the first test run. If the script has run without errors, you should see the following graphs in the graphical logger.

In the next step, extend the script to repeat the generation of the sawtooth cyclically until the user presses the Request Script Stop ❶ button. To do this, insert a Conditional Loop ❷ in front of the sawtooth loop. In the configuration area of the function, switch to the JavaScript area ❸ and enter the following condition:

❹ $StopRequested == false

This means that this loop is repeated continuously as long as the condition is fulfilled, i.e. as long as the global variable $StopRequested has the value false. The variable $StopRequested is a global script variable that is always present. After starting the script this variable always has the value false. Only when the user presses the button Request Script Stop ❶, the value of the variable is set to true.

Now you can insert the sawtooth loop into the conditional loop. Click on the Counting Loop ❺ and drag it to the Conditional Loop ❷. The counting loop is then inserted into the conditional loop. Now restart the script. The generation of the sawtooth is now repeated until you press the button Request Script Stop ❶.

After a few cycles, press the Request Script Stop ❶ button to end the script. If the script has run without errors, you should see the following graphs in the graphical logger.

Your flow profile script is almost finished. To improve the clarity, you can combine the variables you declared at the beginning of the script in a variable group (Variable Declarations). Insert a Variable Declarations function as the first function in the script. Then select all variables. Click on the first Create Variable function and then click on the last Create Variable function while holding down the Shift key – just as you would select several files in your file explorer.

Afterwards you can move all marked variables with the mouse into the variable group. With this you have grouped the variables and improved the clarity and readability of the script. In addition, it is now easier to move this group of variables to another position. Your script should now look like this:

In the second part of the tutorial you will learn how to modify the script so that sinusoidal flow profiles can be generated with the help of JavaScript functions. You will also learn how to add an initialization routine to the script that pulls up the syringes and how to record calculated values using virtual I/O channels in the graphical logger. Finally, you will receive tips on how to improve the readability of your script and document your script.

The QmixElements project with simulated devices and the script created in the tutorial can be downloaded here.

In microfluidic applications, e.g. when detecting or measuring droplets, it may be necessary to acquire certain analog measured values with a higher sampling frequency than was previously possible in the QmixElements software. For this requirement we now have a new QmixElements add-on: the DAQ (Data Acquisition) add-on. The add-on supports the multifunction I / O devices of the USB-600x series from National Instruments. For example, you can use the USB-6002 to capture data from up to 8 channels at the same time with a sample rate of up to 6.2 KHz per channel.

For this blog post we use the NI USB-6002 to describe the DAQ plug-in functionality.

The USB-6002 device is simply connected to the PC via USB and has 8 analog inputs with a resolution of 12 bits. In addition, there are 4 digital inputs and 4 digital outputs available to the user. To use the USB-6002 in the QmixElements software, you only have to configure it like any other CETONI device in the device configurator.

In the software you can then use the configuration window for the new DAQ plot to set which analog and digital channels are to be recorded in the plot and which sample rate is used for recording. All analog and digital channels of the USB-6002 are available in the software as normal I / O channels and can therefore be used, for example, in script programs to trigger functions or to control other devices (e.g. pump flow rate).

As soon as you start recording in the DAQ plot, the measured values of all configured channels are recorded in real time and displayed in the plot. At the same time, the measured values are recorded in a CSV file and can therefore be imported and evaluated by external tools.

This provides you with a powerful tool for recording measured values with higher sample rates. In addition, the DAQ add-on gives you the option of integrating an existing NI USB-600x device into the software in order to obtain additional I / O channels.

Whoever conducts top research or works as a developer to solve problems creatively needs hardware and software that allows him to concentrate fully on his task. With QmixElements, we provide a comprehensive laboratory automation platform that ensures this and also opens up new possibilities. To make it even easier to use, we are constantly working on the further development of the software and are constantly implementing new features.

In previous posts we have already talked in detail about the new advanced docking system and baseline correction for the spectroscopy plugin. But our latest update offers many more features, which we would like to introduce to you here.

Settings, Autostart and more…

With the new Settings dialog, you can now find important global or plugin-specific configuration settings bundled in one place. There you can activate the new Auto-Connect function or configure the script which should be loaded and run when starting the application.

QmixElements Settings Dialog

With these new functions it is now possible to start the software and a script fully automatically after switching on the control computer. You only have to perform the following steps:

1. QmixElements Autostart
   Use the features of the operating system (autostart, task scheduling) for the automatic start of QmixElements after the operating system has been booted.
2. Auto connect
   Activate the Enable auto connect setting in the settings dialog and the software automatically connects to the attached devices after startup.
3. Script Autostart
   In the settings dialog, configure the Autostart Scriptfile and activate the option Enable script autostart. After connecting, the software will automatically start the configured script.

We are pleased to announce the first release of the QmixElements software in 2019. With this release we extend the functional range of the CETONI devices by new features, functions and we supplement the software with many useful details or improve existing functions. Highlight of the new QmixElements version v20190108 is the improved graphical user interface with the new Advanced Docking System.

In the previous QmixElements software there was a central area for switching workspaces. Individual tool windows could be freely arranged and moved around this central area. So it was possible to customize the graphical user interface to a limited extent.

However, the individual workspaces displayed in the central area could not be moved and only one workspace was visible at a time. For example, one could work either in the user interface of the neMESYS pumps, or in the positioning map for the rotAXYS or one could show the graphical logger. A simultaneous display was not possible up to now.

Dock everywhere – no central widget

In the new QmixElements software this limitation no longer exists. Due to the new advanced docking system there is no longer a central workspace, but only single views (windows) which can be positioned freely in the graphical user interface or can be detached from it.

You can dock all views at any edge of the main window or in any other view – so you can dock virtually anywhere and move any view to any position. Markers make it easy to see where you can insert a view.

Detach views as separate windows – perfect for multi-monitor use

Not only can you move all views to new positions in the main window, but you can also detach the individual views completely from the application window and move them as a stand-alone window. This allows you, for example, to move each individual view to a different monitor. This ensures that you always keep an eye on important information and make optimum use of the available screen space.

Individual views can be “docked” to any position not only in the main window of the application, but in every window and every individual view of the application. This allows you to distribute all views across multiple windows or even across multiple monitors.

Moving Multiple Views Simultaneously

You can not only move individual views and detach them from the user interface, but also complete view groups. If you have grouped several views in tabs, you can remove the entire view group by clicking on the title bar of the group and pulling it out of its position. This allows you to quickly customize even complex layouts.

Perspectives – fast switching of the entire user interface

A certain layout of views that is perfectly suited for a particular application or user may be less suited for other tasks or other users. The new graphical user interface helps you to switch the complete layout with just one mouse click and to completely change the arrangement of views and windows in a second. The software offers so-called “perspectives” for this purpose. A perspective is nothing more than a certain layout of views with a fixed name. This means that if you have found the perfect configuration of views for a certain task, simply save this configuration under a name as a perspective.

Other perspectives can be created for other tasks and other users. Later, you can simply select a perspective from the perspective menu to quickly switch the interface layout for a new task.

The video on our youtube channel gives you a first impression of what is possible with the new advanced docking system of the QmixElements software.

The spectroscopy plugin for the new QmixElements version v20180824 now comes with a real-time baseline correction. This enables the software to correct baseline shifts in real time while the spectra are being recorded. A subsequent baseline correction can thus be omitted. This facilitates the later evaluation of the data and simplifies the post-processing of the recorded spectra.

Baseline variation is a problem that occurs with many types of spectral data. Typically, it is a linear or nonlinear addition to the spectra that results in expected zero measurements reaching a positive value. This can be caused, for example, by the fluorescence during the recording of Raman spectra. A baseline can be described as the slowly varying curve that runs through the lower part of the spectra without the jumps of the peaks.

The baseline display can be activated in the software so that it appears as a red line in the live display of the spectral data.

During baseline correction, a baseline is calculated by the selected algorithm. If baseline correction is activated, the calculated baseline is subtracted from the spectral data after each spectral acquisition in order to correct the baseline variation. You see the result immediately in the live display of the spectral data for the respective spectrometer.

With the new Python integration for the Qmix SDK you can develop small applications in the shortest time, automate certain dosing processes or realize your own analyses. The main advantage of Python is its ease of programming, which significantly reduces the time required to develop, debug and maintain the code. In the following example we show you how easy and fast you can implement an application with Python and the Qmix SDK.

Installation

To install, simply use the Qmix SDK installation package for Windows. The SDK will be installed in a folder of your choice.

Integration

To include the Qmix SDK in your Python script you have to add the path containing the Qmix SDK modules to the module search path. In order for Python to load the shared libraries (DLLs) of the SDK, you must then add the path containing the DLLs to the Windows search path. All details are also available in the online documentation.

import sys
import os
QMIXSDK_DIR = "C:/temp/QmixSDK-64bit_20180626"
sys.path.append(QMIXSDK_DIR + "/lib/python")
os.environ['PATH'] += os.pathsep + QMIXSDK_DIR

 

Now you can import the modules of the Qmix SDK Python integration.

from qmixsdk import qmixbus
from qmixsdk import qmixpump

 

The first Python application

Now you can start developing your first application. The following program shows a small example. First a bus object is created, initialized with the path to a device configuration and then the communication is started. Then we create a pump object and connect it to the first pump in the SDK – device index 0. As a test we print the name of the pump with the print function.

def main():
"""
A small example that shows how to use the Qmix SDK for Python
"""
bus = qmixbus.Bus()
bus.open("testconfig_qmixsdk", "")
bus.start()
pump = qmixpump.Pump()
pump.lookup_by_device_index(0)
print(pump.get_device_name())

 

In the next step we perform a reference run with the calibrate function to determine the zero position of the pump. Before the reference run, we clear any remaining errors (clear_fault) and enable the pump (enable). With the help of a timeout timer we wait until the calibration is finished.

pump.clear_fault()
pump.enable(True)
pump.calibrate()
timeout_timer = qmixbus.PollingTimer(10000)
result = timeout_timer.wait_until(pump.is_calibration_finished, True)
print(result)

 

The pump is now initialized and we can start dosing. For this we set the units for volume and flow rate to milliliter and milliliter per second. As a test we will output the unit for the flow with the print function. Then we configure the syringe to be used. We use a syringe with 1 mm inner diameter and 60 mm plunger stroke. In line 41 we start the aspiration (aspirate) of 0.02 ml with a flow rate of 0.004 ml/s. With a timeout timer we wait again until the dosage is finished.

pump.set_volume_unit(UnitPrefix.milli, VolumeUnit.litres)
pump.set_flow_unit(UnitPrefix.milli, VolumeUnit.litres, TimeUnit.per_second)
print(pump.get_flow_unit()
pump.set_syringe_param(1, 60)
print(pump.get_syringe_param())
print(pump.get_volume_max())
print(pump.get_flow_rate_max())
pump.aspirate(0.02, 0.004)
timeout_timer.set_period(10000)
result = timeout_timer.wait_until(pump.is_pumping, False)
print(result)

 

At the end of the program we stop the communication and call the close function of the bus object to release all resources again.

bus.stop()
bus.close()

 

We hope you got a small impression of how powerful and simple the Qmix SDK for Python is. You can download the Python example from this blog post here.