new version

.gitignore

@@ -0,0 +1,8 @@
+/bin
+/target
+/build
+.gradle
+.settings
+.project
+.classpath
+/schema/

Readme.md

@@ -35,7 +35,7 @@ usage: viewer
 
 # Development
 When checking out the project from the repository there is the `target/generated-sources/xjc` folder missing.
-After checking out the project execute `mvn compile` to create the folder and the required classes. 
+After checking out the project execute `mvn compile` to create the folder and the required classes.
 
 To build project use `mvn clean install`.
 
@@ -104,4 +104,62 @@ GET fda/{trackingId}/done
 
 # Notes
 ## Upgrade FDA 1.x to 2.x
-In existing fda.properties file the following property need to be added: `ch.psi.fda.aq.data.dir=../data`
+In existing fda.properties file the following property need to be added: `ch.psi.fda.aq.data.dir=../data`
+
+## Upgrade FDA 2.6.1
+There are 2 new properties for crlogic:
+
+```
+ch.psi.fda.aq.crlogic.ioc=X05LA-VME-ES2
+ch.psi.fda.aq.crlogic.prefix=X05LA-ES2-CRL
+```
+
+
+# FDAQ
+## Overview
+This software is used to readout the FDAQ box developed at X10SA.
+On The FDAQ box there are 2 socket servers, one for retrieving the data and one for resetting the socket
+server for data retrieval.
+
+The fdaq code provides exactly 2 functionalities. It can query on the data socket for data (need to specifying how many data point to read),
+and it can send a reset request on the reset channel.
+
+## Usage
+
+To acquire data into a file use:
+
+```
+java -jar ch.psi.fda.fdaq-<version>.jar <file>
+```
+
+You can terminate the acquisition with *CTRL+C*. If you submit 2 consequtive *CTRL+C* the program will terminate immediately (and data might be lost);
+
+
+
+This will take the default connections settings:
+
+  * Hostname: mchip015.psi.ch
+  * Port: 2233
+  * Kill Port: 2234
+  * Number Of Elements: Integer.MAX_VALUE/2
+
+If you need to specify different settings create a property files with following content:
+
+```
+ch.psi.fda.fdaq.hostname=myhost
+ch.psi.fda.fdaq.port=1234
+ch.psi.fda.fdaq.killPort=4321
+```
+
+Use `-Dch.psi.fda.fdaq.config.file=<file>` to use this property file as base configuration.
+
+
+
+## Development
+A standalone jar can be build via `mvn clean compile assembly:single`.
+
+To upload the latest version to the artifact repository use ` mvn clean compile deploy`.
+
+
+## Notes
+Trigger port is `Trigger In 1`. For testing apply a 1kHz signal.

build.gradle

@@ -0,0 +1,92 @@
+apply plugin: 'java'
+apply plugin: 'eclipse'
+
+sourceCompatibility = 1.7
+
+version = '3.0.0'
+
+buildscript {
+  repositories {
+    maven {
+      url "https://plugins.gradle.org/m2/"
+    }
+  }
+  dependencies {
+    classpath "com.github.jacobono:gradle-jaxb-plugin:1.3.5"
+  }
+}
+
+apply plugin: "com.github.jacobono.jaxb"
+
+repositories {
+    mavenCentral()
+    maven { url "http://artifacts.psi.ch/artifactory/libs-releases" }
+    maven { url "http://artifacts.psi.ch/artifactory/libs-snapshots" }
+}
+
+dependencies {
+	compile 'ch.psi:jcae:2.4.1'
+	compile 'com.google.inject:guice:3.0'
+	compile 'org.glassfish.jersey.containers:jersey-container-grizzly2-http:2.5.1'
+	compile 'org.glassfish.jersey.media:jersey-media-sse:2.5.1'
+	compile 'org.glassfish.jersey.media:jersey-media-json-jackson:2.5.1'
+	compile 'org.zeromq:jeromq:0.3.4'
+	compile 'org.apache.commons:cli:1.2'
+	// For reading/writing Matlab files
+	compile 'com.jmatio:jmatio:0.2u2psi1'
+	// Library for reading/writing XDR Format (MDA)
+	compile 'org.freehep:freehep-xdr:2.0.4'
+	compile 'ch.psi:plot:2.1-SNAPSHOT'
+	
+	compile 'com.google.guava:guava:>15.0'
+	
+	compile 'com.sun.mail:javax.mail:1.5.0'
+	compile 'javax.inject:javax.inject:1'
+	compile 'org.python:jython:2.5.3'
+	compile 'com.fasterxml.jackson.core:jackson-databind:2.5.2'
+	
+	
+	jaxb 'com.sun.xml.bind:jaxb-xjc:2.2.7-b41'
+    jaxb 'com.sun.xml.bind:jaxb-impl:2.2.7-b41'
+    jaxb 'javax.xml.bind:jaxb-api:2.2.7'
+	
+    testCompile 'junit:junit:4.+'
+}
+
+task sourcesJar(type: Jar, dependsOn: classes) {
+    classifier = 'sources'
+    from sourceSets.main.allSource
+}
+
+/*
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    classifier = 'javadoc'
+    from javadoc.destinationDir
+}
+*/
+
+artifacts {
+    archives sourcesJar
+    //archives javadocJar
+}
+
+jaxb{
+	xsdDir = "src/main/resources"
+	xjc {
+	     generatePackage = "ch.psi.fda.model.v1" 
+	}
+}
+
+apply plugin: 'maven'
+
+uploadArchives {
+    repositories {
+        mavenDeployer {
+            repository(url: "http://artifacts.psi.ch/artifactory/libs-snapshots-local"){
+            	authentication(userName: "upload", password: "{DESede}eWKHxAtQ2Dc=")
+            }
+            pom.groupId = 'ch.psi'
+            pom.artifactId = 'fda'
+        }
+    }
+}

ch.psi.fda/.classpath

@@ -1,36 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" output="target/classes" path="src/main/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/classes" path="src/main/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
-		<attributes>
-			<attribute name="optional" value="true"/>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
-		<attributes>
-			<attribute name="maven.pomderived" value="true"/>
-		</attributes>
-	</classpathentry>
-	<classpathentry kind="output" path="target/classes"/>
-</classpath>

ch.psi.fda/.gitignore

@@ -1 +0,0 @@
-/target

ch.psi.fda/.project

@@ -1,23 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>ch.psi.fda</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.m2e.core.maven2Builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.m2e.core.maven2Nature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

ch.psi.fda/.settings/org.eclipse.core.resources.prefs

@@ -1,3 +0,0 @@
-eclipse.preferences.version=1
-encoding//src/main/java=UTF-8
-encoding//src/test/java=UTF-8

ch.psi.fda/.settings/org.eclipse.jdt.core.prefs

@@ -1,5 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
-org.eclipse.jdt.core.compiler.compliance=1.7
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.source=1.7

ch.psi.fda/.settings/org.eclipse.m2e.core.prefs

@@ -1,5 +0,0 @@
-#Tue Oct 18 15:52:42 CEST 2011
-activeProfiles=
-eclipse.preferences.version=1
-resolveWorkspaceProjects=true
-version=1

ch.psi.fda/ReleaseNotes.md

@@ -1,2 +0,0 @@
-# 3.0.0
-  * Update the fda.properties file and replace ch.psi.fda.aq.data.baseDirectory with ch.psi.fda.aq.data.dir.

ch.psi.fda/pom.xml

@@ -1,155 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	<groupId>ch.psi</groupId>
-	<artifactId>fda</artifactId>
-	<version>2.4.3</version>
-
-	<dependencies>
-
-		<dependency>
-			<groupId>ch.psi</groupId>
-			<artifactId>ch.psi.fda.core</artifactId>
-			<version>2.3.0</version>
-		</dependency>
-
-		<!-- These 3 libraries are just needed for testing -->
-		<dependency>
-			<groupId>ch.psi.fda</groupId>
-			<artifactId>ch.psi.fda.xscan</artifactId>
-			<version>2.3.2</version>
-		</dependency>
-		<dependency>
-			<groupId>ch.psi</groupId>
-			<artifactId>ch.psi.fda.cdump</artifactId>
-			<version>2.3.0</version>
-		</dependency>
-		<dependency>
-			<groupId>ch.psi</groupId>
-			<artifactId>ch.psi.fda.fdaq</artifactId>
-			<version>2.3.0</version>
-		</dependency>
-
-		<dependency>
-			<groupId>ch.psi</groupId>
-			<artifactId>jcae</artifactId>
-			<version>2.4.1</version>
-		</dependency>
-
-		<dependency>
-			<groupId>ch.psi</groupId>
-			<artifactId>plot</artifactId>
-			<version>1.1.31</version>
-		</dependency>
-
-		<dependency>
-			<groupId>com.google.inject</groupId>
-			<artifactId>guice</artifactId>
-			<version>3.0</version>
-		</dependency>
-
-		<dependency>
-			<groupId>org.glassfish.jersey.containers</groupId>
-			<artifactId>jersey-container-grizzly2-http</artifactId>
-			<version>2.5.1</version>
-		</dependency>
-
-		<dependency>
-			<groupId>org.glassfish.jersey.media</groupId>
-			<artifactId>jersey-media-sse</artifactId>
-			<version>2.5.1</version>
-		</dependency>
-
-		<dependency>
-			<groupId>org.glassfish.jersey.media</groupId>
-			<artifactId>jersey-media-json-jackson</artifactId>
-			<version>2.5.1</version>
-		</dependency>
-
-		<dependency>
-			<groupId>org.jeromq</groupId>
-			<artifactId>jeromq</artifactId>
-			<version>0.2.0</version>
-		</dependency>
-
-		<dependency>
-			<groupId>org.apache.commons</groupId>
-			<artifactId>cli</artifactId>
-			<version>1.2</version>
-		</dependency>
-
-		<!-- Library to Read Matlab Files -->
-		<dependency>
-			<groupId>com.jmatio</groupId>
-			<artifactId>jmatio</artifactId>
-			<version>0.2u2psi1</version>
-		</dependency>
-		<!-- Library for reading/writing XDR Format (MDA) -->
-		<dependency>
-			<groupId>org.freehep</groupId>
-			<artifactId>freehep-xdr</artifactId>
-			<version>2.0.4</version>
-		</dependency>
-
-		<dependency>
-			<groupId>junit</groupId>
-			<artifactId>junit</artifactId>
-			<version>4.8.2</version>
-			<scope>test</scope>
-		</dependency>
-	</dependencies>
-
-	<build>
-		<plugins>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<configuration>
-					<encoding>UTF-8</encoding>
-					<source>1.7</source>
-					<target>1.7</target>
-				</configuration>
-			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-javadoc-plugin</artifactId>
-				<configuration>
-					<additionalparam>-Xdoclint:none</additionalparam> <!-- Disable Java8 strict Javadoc checking -->
-				</configuration>
-				<executions>
-					<execution>
-						<id>attach-javadocs</id>
-						<goals>
-							<goal>jar</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-source-plugin</artifactId>
-				<executions>
-					<execution>
-						<id>attach-sources</id>
-						<goals>
-							<goal>jar</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-		</plugins>
-	</build>
-
-	<distributionManagement>
-		<snapshotRepository>
-			<id>i.snapshots</id>
-			<name>Artifactory Snapshots</name>
-			<url>http://yoke.psi.ch:8081/artifactory/libs-snapshots-local</url>
-		</snapshotRepository>
-		<repository>
-			<id>i.releases</id>
-			<name>Atrifactory Releases</name>
-			<url>http://yoke.psi.ch:8081/artifactory/libs-releases-local</url>
-		</repository>
-	</distributionManagement>
-</project>

ch.psi.fda/src/main/java/ch/psi/fda/ui/visualizer/Visualizer.java

@@ -1,341 +0,0 @@
-/**
- * 
- * Copyright 2010 Paul Scherrer Institute. All rights reserved.
- * 
- * This code is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- * 
- * This code is distributed in the hope that it will be useful,
- * but without any warranty; without even the implied warranty of
- * merchantability or fitness for a particular purpose. See the
- * GNU Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public License
- * along with this code. If not, see <http://www.gnu.org/licenses/>.
- * 
- */
-
-package ch.psi.fda.ui.visualizer;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import javax.swing.JPanel;
-import javax.swing.SwingUtilities;
-
-import com.google.common.eventbus.Subscribe;
-
-import ch.psi.fda.messages.DataMessage;
-import ch.psi.fda.messages.EndOfStreamMessage;
-import ch.psi.fda.messages.StreamDelimiterMessage;
-import ch.psi.fda.vdescriptor.Series;
-import ch.psi.fda.vdescriptor.VDescriptor;
-import ch.psi.fda.vdescriptor.XYSeries;
-import ch.psi.fda.vdescriptor.XYZSeries;
-import ch.psi.fda.vdescriptor.YSeries;
-import ch.psi.fda.vdescriptor.YZSeries;
-import ch.psi.plot.Plot;
-import ch.psi.plot.xy.LinePlot;
-import ch.psi.plot.xy.XYSeriesCollectionP;
-import ch.psi.plot.xy.XYSeriesP;
-import ch.psi.plot.xyz.MatrixPlot;
-import ch.psi.plot.xyz.MatrixPlotData;
-
-/**
- * Visualizer for visualizing data
- */
-public class Visualizer {
-	
-	private static Logger logger = Logger.getLogger(Visualizer.class.getName());
-	
-	private boolean updateAtStreamElement = true;
-	private boolean updateAtStreamDelimiter = true;
-	private boolean updateAtEndOfStream = false;
-	
-	private int ecount;
-	private boolean clearPlot;
-	private List<SeriesDataFilter> filters;
-	
-	private boolean first = true;
-	
-	public Visualizer(VDescriptor vdescriptor){
-		filters = new ArrayList<SeriesDataFilter>();
-		
-		for(ch.psi.fda.vdescriptor.Plot vplot: vdescriptor.getPlots()){
-			if(vplot instanceof ch.psi.fda.vdescriptor.LinePlot){
-				ch.psi.fda.vdescriptor.LinePlot lp = (ch.psi.fda.vdescriptor.LinePlot) vplot;
-				
-				// Create plot for visualization
-				ch.psi.plot.xy.LinePlot plot = new ch.psi.plot.xy.LinePlot(lp.getTitle());
-				
-				for(Series s: lp.getData()){
-					if(s instanceof XYSeries){
-						XYSeries sxy = (XYSeries)s;
-						XYSeriesDataFilter filter = new XYSeriesDataFilter(sxy.getX(), sxy.getY(), plot);
-						filter.setSeriesName(sxy.getY());
-						filters.add(filter);
-					}
-					else if(s instanceof YSeries){
-						YSeries sy = (YSeries)s;
-						
-						XYSeriesArrayDataFilter filter = new XYSeriesArrayDataFilter(sy.getY(), plot);
-//						filter.setMaxSeries(lp.getMaxSeries()*lp.getY().size()); // Workaround - keep for each array max series
-//						filter.setOffset(lp.getOffset());
-//						filter.setSize(lp.getSize());
-						filter.setSeriesName(sy.getY());
-						filters.add(filter);
-					}
-				}
-				
-			}
-			else if(vplot instanceof ch.psi.fda.vdescriptor.MatrixPlot){
-				
-				// MatrixPlot does currently not support RegionPositioners because of the
-				// plotting problems this would cause. If regions of the positioner have different
-				// step sizes it is not easily possible (without (specialized) rasterization) to plot the data.
-				
-				ch.psi.fda.vdescriptor.MatrixPlot lp = (ch.psi.fda.vdescriptor.MatrixPlot) vplot;
-				MatrixPlotData data = new MatrixPlotData(lp.getMinX(), lp.getMaxX(), lp.getnX(), lp.getMinY(), lp.getMaxY(), lp.getnY());
-				MatrixPlot plot = new MatrixPlot(lp.getTitle(), data);
-				
-				for(Series s: lp.getData()){
-					if(s instanceof XYZSeries){
-						XYZSeries sxyz = (XYZSeries) s;
-						filters.add(new XYZSeriesDataFilter(sxyz.getX(), sxyz.getY(), sxyz.getZ(), plot));
-						
-					}
-					else if(s instanceof YZSeries){
-						YZSeries syz = (YZSeries) s;
-						XYZSeriesArrayDataFilter filter = new XYZSeriesArrayDataFilter(syz.getY(), syz.getZ(), 0, 0, plot);
-						filters.add(filter);
-						
-					}
-				}
-			}
-		}
-	}
-	
-	
-	@Subscribe
-	public void onDataMessage(final DataMessage message){
-		
-			if(first){
-				first=false;
-//				filters = VisMapper.mapVisualizations(visualizations);
-				// TODO somehow handle dimension / clear
-			}
-		
-			// Clear is here as the plot should not be cleared after the last point is plotted
-			// but just before the first point of the next plot (cycle)
-			if (clearPlot) {
-				for (SeriesDataFilter f: filters) {
-					Plot plot = f.getPlot();
-					if(plot instanceof MatrixPlot){
-						((MatrixPlotData) ((MatrixPlot)plot).getData()).clear();
-					}
-				}
-				clearPlot = false;
-			}
-
-			for(SeriesDataFilter filter: filters){
-				if(filter instanceof XYSeriesDataFilter){
-					XYSeriesDataFilter xyfilter = (XYSeriesDataFilter) filter;
-					
-					if(xyfilter.getActualSeries()==null || xyfilter.isNewseries()){
-						// First series that is filled by this filter!
-						XYSeriesP s = new XYSeriesP(xyfilter.getSeriesName() + " " + ecount + "-" + xyfilter.getCount());
-						((LinePlot)xyfilter.getPlot()).getData().addSeries(s);
-						xyfilter.setActualSeries(s);
-						xyfilter.setNewseries(false);
-					}
-					
-					XYSeriesP series = xyfilter.getActualSeries(); // TODO Does not work with multiple series filter per plot !!!!
-					
-					// There might be other values than double in the data, therefore we have to check for it
-					Object dX = message.getData(xyfilter.getIdX());
-					Object dY = message.getData(xyfilter.getIdY());
-					Double dataX = Double.NaN;
-					Double dataY = Double.NaN;
-					if(dX instanceof Double){
-						dataX = (Double) dX;
-					}
-					if(dY instanceof Double){
-						dataY = (Double) dY;
-					}
-					
-					// Add Data to the series
-					series.add(dataX , dataY, updateAtStreamElement);
-				}
-				if(filter instanceof XYSeriesArrayDataFilter){
-					final XYSeriesArrayDataFilter xyfilter = (XYSeriesArrayDataFilter) filter;
-					
-					// Ensure that there is no concurrent modification exception or synchronization problems with the
-					// Swing update task
-					SwingUtilities.invokeLater(new Runnable(){
-
-						@Override
-						public void run() {
-							XYSeriesP series = new XYSeriesP(xyfilter.getSeriesName() + "-" + xyfilter.getCount()); // Series name must be unique
-							xyfilter.incrementCount();
-
-//								((LinePlot)xyfilter.getPlot()).getData().removeAllSeries(); // Remove all series from the data
-							// If we can agree only to display one series at a time also a clear() on the actual series is better
-							XYSeriesCollectionP sc = ((LinePlot)xyfilter.getPlot()).getData();
-							sc.addSeries(series);
-							
-							// Remove outdated series
-							if(sc.getSeriesCount()>xyfilter.getMaxSeries()){
-								// Remove oldest series
-								sc.removeSeries(0);
-							}
-							
-							double[] data = message.getData(xyfilter.getIdY());
-							// Copy data starting from offset to size
-							int size = data.length;
-							int offset = xyfilter.getOffset();
-							if(xyfilter.getSize()>0 && offset+xyfilter.getSize()<data.length){
-								size = offset + xyfilter.getSize();
-							}
-							for(int i=offset;i<size;i++){
-								series.add(i,data[i], false); // Do not fire change event - this would degrade performance drastically
-							}
-							series.fireSeriesChanged();
-						}
-						
-					});
-				}
-				else if(filter instanceof XYZSeriesDataFilter){
-					XYZSeriesDataFilter xyzfilter = (XYZSeriesDataFilter) filter;
-					try{
-						((MatrixPlot)xyzfilter.getPlot()).getData().addData((Double) message.getData(xyzfilter.getIdX()),(Double) message.getData(xyzfilter.getIdY()), (Double) message.getData(xyzfilter.getIdZ()));
-					}
-					catch (Exception e) {
-						// Ignore if something goes wrong while adding a datapoint
-						logger.log(Level.WARNING, "Unable to plot datapoint in matrix plot", e);
-					}
-				}
-				else if(filter instanceof XYZSeriesArrayDataFilter){
-					XYZSeriesArrayDataFilter xyzfilter = (XYZSeriesArrayDataFilter) filter;
-					try{
-						double[] data = (double[]) message.getData(xyzfilter.getIdZ());
-						double y = (Double) message.getData(xyzfilter.getIdY());
-//						int offset = xyzfilter.getOffset();
-//						int size = xyzfilter.getSize();
-//						for(int i=offset;i<offset+size; i++){
-						for(int i=0;i<data.length; i++){	
-							((MatrixPlot)xyzfilter.getPlot()).getData().addData(i, y, data[i]);
-						}
-						// Update data if update by point is enabled
-						if(updateAtStreamElement){
-							xyzfilter.getPlot().update();
-						}
-					}
-					catch (Exception e) {
-						// Ignore if something goes wrong while adding a datapoint
-						logger.log(Level.WARNING, "Unable to plot datapoint in matrix plot", e);
-					}
-				}
-			}
-	}
-	
-	
-	@Subscribe
-	public void onStreamDelimiterMessage(StreamDelimiterMessage message){
-			for(SeriesDataFilter filter: filters){
-				if(filter instanceof XYSeriesDataFilter){
-					// Create new series
-					XYSeriesDataFilter xyfilter = (XYSeriesDataFilter) filter;
-//					if (message.getNumber() == xyfilter.getDimensionX()) {
-						if (message.getNumber() == 0) { // TODO need to check this - here we assume that always at the lowest level we create a new series 
-						// Indicate to create new series at the next message
-						xyfilter.setCount(xyfilter.getCount()+1); // Increment count of the filter
-						xyfilter.setNewseries(true);
-					}
-				}
-			}
-
-			// Update matrix plot at the end of each line
-			if(updateAtStreamDelimiter){
-				for(SeriesDataFilter f: filters){
-					Plot plot = f.getPlot();
-//				for (Plot plot: plots) {
-					if(plot instanceof MatrixPlot){
-						((MatrixPlot)plot).update();
-					}
-					else if(plot instanceof LinePlot){
-						((LinePlot) plot).update();
-					}
-				}
-			}
-
-			// Clear matrix plot if iflag is encountered
-			// TODO: One need to check whether the iflag belongs to a delimiter
-			// of a higher dimension than the highest dimension (axis) that
-			// is involved in the plot
-			if (message.isIflag()) {
-				clearPlot = true;
-			}
-	}
-	
-	@Subscribe
-	public void onEndOfStreamMessage(EndOfStreamMessage message){
-		ecount++;
-		
-		// Update plots if updateAtEndOfStream flag is set
-		if(updateAtEndOfStream){
-			// Update matrix plots
-			for(SeriesDataFilter f: filters){
-				Plot plot = f.getPlot();
-				if(plot instanceof MatrixPlot){
-					((MatrixPlot)plot).update();
-					((MatrixPlot)plot).adaptColorMapScale(); // Update color scale at the end
-				}
-				else if(plot instanceof LinePlot){
-					((LinePlot) plot).update();
-				}
-			}
-		}
-	}
-	
-	public void configure(){
-		ecount = 0;
-		clearPlot = false;
-	}
-	
-	/**
-	 * Get the plot panels for the visualizations
-	 * @return	List of configured JPanels
-	 */
-	public List<JPanel> getPlotPanels(){
-		List<JPanel> panels = new ArrayList<JPanel>();
-		for(SeriesDataFilter f: filters){
-			panels.add(f.getPlot().getChartPanel());
-		}
-		
-		return panels;
-	}
-
-	public boolean isUpdateAtStreamElement() {
-		return updateAtStreamElement;
-	}
-	public void setUpdateAtStreamElement(boolean updateAtStreamElement) {
-		this.updateAtStreamElement = updateAtStreamElement;
-	}
-	public boolean isUpdateAtStreamDelimiter() {
-		return updateAtStreamDelimiter;
-	}
-	public void setUpdateAtStreamDelimiter(boolean updateAtStreamDelimiter) {
-		this.updateAtStreamDelimiter = updateAtStreamDelimiter;
-	}
-	public boolean isUpdateAtEndOfStream() {
-		return updateAtEndOfStream;
-	}
-	public void setUpdateAtEndOfStream(boolean updateAtEndOfStream) {
-		this.updateAtEndOfStream = updateAtEndOfStream;
-	}
-	
-}

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Thu Mar 17 08:20:35 CET 2016
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.2.1-bin.zip

gradlew

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

src/main/java/ch/psi/fda/DescriptorProvider.java

@@ -0,0 +1,17 @@
+package ch.psi.fda;
+
+import java.io.File;
+
+import ch.psi.fda.edescriptor.EDescriptor;
+import ch.psi.fda.vdescriptor.VDescriptor;
+
+public interface DescriptorProvider {
+
+	public void load(File ... files );
+	
+	public EDescriptor getEDescriptor();
+	public VDescriptor getVDescriptor();
+	
+	public Class<?> getEDescriptorClass();
+	
+}

src/main/java/ch/psi/fda/EContainer.java

@@ -0,0 +1,28 @@
+package ch.psi.fda;
+
+public interface EContainer {
+
+	/**
+	 * Initialize execution container like required resources, etc.
+	 */
+	public void initialize();
+	
+	/**
+	 * Executes the logic implemented by the ExecutionContainer
+	 * Execute is a blocking function and must not return before the actual logic is executed
+	 */
+	public void execute();
+	
+	/**
+	 * Try to abort the execution of the logic
+	 */
+	public void abort();
+	
+	public boolean isActive();
+	
+	/**
+	 * Destroy execution container and free all allocated resources
+	 */
+	public void destroy();
+	
+}

src/main/java/ch/psi/fda/EContainerFactory.java

@@ -0,0 +1,22 @@
+package ch.psi.fda;
+
+import ch.psi.fda.edescriptor.EDescriptor;
+
+import com.google.common.eventbus.EventBus;
+
+public interface EContainerFactory {
+
+	/**
+	 * Check whether the factory supports 
+	 * @param descriptor
+	 * @return
+	 */
+	public boolean supportsEDescriptor(EDescriptor descriptor);
+	
+	/**
+	 * Create the execution container based on the passed descriptor
+	 * @param descriptor
+	 * @return
+	 */
+	public EContainer getEContainer(EDescriptor descriptor, EventBus bus);
+}

src/main/java/ch/psi/fda/aq/AcquisitionConfiguration.java

@@ -0,0 +1,187 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.aq;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Properties;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class AcquisitionConfiguration {
+	
+	
+	private static final Logger logger = Logger.getLogger(AcquisitionConfiguration.class.getName());
+	
+	public final static String FDA_CONFIG_FILE = "ch.psi.fda.xscan.config.file";
+	
+	private String crlogicPrefix;
+	private String crlogicIoc;
+	
+	/**
+	 * Base directory for data. The directory may contain date macros. The string may contain any @see java.text.SimpleDateFormat
+	 * patterns within ${ } brackets. The macros are resolved with the actual time while the get method
+	 * of this property is called.
+	 */
+	private String dataBaseDirectory = System.getProperty("user.home");
+	/**
+	 * Prefix of the data file. The prefix may contain date macros. The string may contain any @see java.text.SimpleDateFormat
+	 * patterns within ${ } brackets. The macros are resolved with the actual time while the get method
+	 * of this property is called.
+	 */
+	private String dataFilePrefix = "";
+	
+	/**
+	 * Maximum time for a actor move
+	 */
+	private Long actorMoveTimeout = 600000l; // 10 Minutes maximum move time 
+	
+	private String smptServer;
+	
+	
+	/**
+	 * Default Constructor
+	 * The constructor will read the configuration from the /fda.properties file (resource) located in the classpath.
+	 */
+	public AcquisitionConfiguration(){
+		loadConfiguration(System.getProperty(FDA_CONFIG_FILE));
+	}
+	
+	/**
+	 * Load configuration from properties file
+	 */
+	public void loadConfiguration(String file) {
+		Properties properties = new Properties();
+		
+		File cfile = null;
+		// Only read in the property file if a file is specified
+		if(file != null){
+			cfile = new File(file);
+			try {
+				properties.load(new FileReader(cfile));
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("Configuration file "+file+" not found", e);
+			} catch (IOException e) {
+				throw new RuntimeException("Cannot read configuration file "+file, e);
+			}
+		}
+		else{
+			logger.warning("No configfile specified !");
+		}
+		
+		// The defaults are set here
+		crlogicPrefix = properties.getProperty(AcquisitionConfiguration.class.getPackage().getName()+".crlogic.prefix", "");
+		crlogicIoc= properties.getProperty(AcquisitionConfiguration.class.getPackage().getName()+".crlogic.ioc", "");
+		
+		dataBaseDirectory = properties.getProperty(AcquisitionConfiguration.class.getPackage().getName()+".data.dir",".");
+		if(cfile!=null && dataBaseDirectory.matches("^\\.\\.?/.*")){ // if basedir starts with . or .. we assume the data directory to be relative to the directory of the configuration file
+			dataBaseDirectory = cfile.getParentFile().getAbsolutePath()+"/"+dataBaseDirectory; 
+		}
+		dataFilePrefix = properties.getProperty(AcquisitionConfiguration.class.getPackage().getName()+".data.filePrefix","");
+		
+		
+		actorMoveTimeout = new Long(properties.getProperty(AcquisitionConfiguration.class.getPackage().getName()+".actorMoveTimeout","600000"));
+		
+		smptServer= properties.getProperty(AcquisitionConfiguration.class.getPackage().getName()+".notification.host","mail.psi.ch");
+		
+	}
+	
+	/**
+	 * Replace ${name} and ${date} macro given string
+	 * @param string
+	 * @param date
+	 * @param name
+	 * @return
+	 */
+	public String replaceMacros(String string, Date date, String name){
+		String newString = string;
+		
+		// Replace scan name macros
+		newString = newString.replaceAll("\\$\\{name\\}", name);
+		
+		
+		// Replace date macros
+		Pattern pattern = Pattern.compile("\\$\\{[a-z,A-Z,-,_,:]*\\}");
+        Matcher matcher = pattern.matcher(newString);
+        while(matcher.find()){
+        	String datePattern = matcher.group();
+        	datePattern = datePattern.replaceAll("\\$\\{", "");
+        	datePattern = datePattern.replaceAll("\\}", "");
+        	SimpleDateFormat datef = new SimpleDateFormat(datePattern);
+        	newString = matcher.replaceFirst(datef.format(date));
+        	matcher = pattern.matcher(newString);
+        }
+		return newString;
+	}
+
+
+	public String getCrlogicPrefix() {
+		return crlogicPrefix;
+	}
+
+	public void setCrlogicPrefix(String crlogicPrefix) {
+		this.crlogicPrefix = crlogicPrefix;
+	}
+	
+	public void setCrlogicIoc(String crlogicIoc) {
+		this.crlogicIoc = crlogicIoc;
+	}
+	public String getCrlogicIoc() {
+		return crlogicIoc;
+	}
+	
+
+	public String getDataBaseDirectory() {
+		return dataBaseDirectory;
+	}
+
+	public void setDataBaseDirectory(String dataBaseDirectory) {
+		this.dataBaseDirectory = dataBaseDirectory;
+	}
+
+	public String getDataFilePrefix() {
+		return dataFilePrefix;
+	}
+
+	public void setDataFilePrefix(String dataFilePrefix) {
+		this.dataFilePrefix = dataFilePrefix;
+	}
+
+	public Long getActorMoveTimeout() {
+		return actorMoveTimeout;
+	}
+
+	public void setActorMoveTimeout(Long actorMoveTimeout) {
+		this.actorMoveTimeout = actorMoveTimeout;
+	}
+
+	public String getSmptServer() {
+		return smptServer;
+	}
+
+	public void setSmptServer(String smptServer) {
+		this.smptServer = smptServer;
+	}
+}

src/main/java/ch/psi/fda/aq/Collector.java

@@ -0,0 +1,102 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.aq;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.messages.Message;
+import ch.psi.fda.messages.Metadata;
+import ch.psi.fda.messages.StreamDelimiterMessage;
+
+/**
+ * Collector class that is collecting and merging data from different Queues.
+ */
+public class Collector {
+	
+	private EventBus bus;
+	private List<MessageListener> listeners = new ArrayList<>();
+	
+	private List<Metadata> metadata;
+	private boolean first = true;
+	
+	public Collector(EventBus b){
+		this.bus = b;
+	}
+	
+	public void addEventBus(EventBus b){
+		MessageListener l = new MessageListener();
+		listeners.add(l);
+		b.register(l);
+	}
+
+	
+	
+	private class MessageListener{
+		
+		private DataMessage message;
+		
+		@Subscribe
+		public void onMessage(Message message){
+			int level = listeners.indexOf(this);
+			if(message instanceof DataMessage){
+				this.message = (DataMessage) message;
+				
+				if(level==0){
+					if(first){
+						metadata = new ArrayList<>();
+						for(int i=listeners.size()-1;i>=0;i--){
+							// Correct/Add dimension information
+							for(Metadata m: listeners.get(i).getMessage().getMetadata()){
+								m.setDimension(i);
+							}
+							metadata.addAll(listeners.get(i).getMessage().getMetadata());
+						}
+						
+					}
+					DataMessage m = new DataMessage(metadata);
+					for(int i=listeners.size()-1;i>=0;i--){
+						m.getData().addAll(listeners.get(i).getMessage().getData());
+					}
+					bus.post(m);
+				}
+			}
+			if(message instanceof EndOfStreamMessage){
+				
+				StreamDelimiterMessage ddm = new StreamDelimiterMessage(level, ((EndOfStreamMessage)message).isIflag());
+				bus.post(ddm);
+				if(level==(listeners.size()-1)){ // if highest dimension then send end of stream
+					bus.post(new EndOfStreamMessage());
+				}
+			}
+		}
+		
+		public DataMessage getMessage(){
+			return message;
+		}
+	}
+	
+}
+

src/main/java/ch/psi/fda/aq/Manipulator.java

@@ -0,0 +1,79 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.aq;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+
+import ch.psi.fda.core.Manipulation;
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.Message;
+import ch.psi.fda.messages.Metadata;
+
+/**
+ * Applies manipulations to the data stream
+ */
+public class Manipulator {
+	
+	private EventBus bus;
+	
+	private final List<Manipulation> manipulations;
+	private boolean first = true;
+	private List<Metadata> metadata = new ArrayList<>();
+	
+	public Manipulator(EventBus b, List<Manipulation> manipulations){
+		this.bus = b;
+		this.manipulations = manipulations;
+	}
+
+	@Subscribe
+	public void onMessage(Message message){
+		if(message instanceof DataMessage){
+			if(first){
+				first=false;
+				
+				metadata.addAll(((DataMessage) message).getMetadata());
+				
+				for(Manipulation manipulation: this.manipulations){
+					manipulation.initialize(this.metadata);
+					
+					// Add manipulation id to metadata
+					this.metadata.add(new Metadata(manipulation.getId(),0)); // Calculated component always belongs to lowes dimension
+				}
+			}
+			
+			
+			DataMessage dm = (DataMessage) message;
+//			message = new DataMessage(metadata);
+			for(Manipulation manipulation: manipulations){
+//                          ((DataMessage)message).getData().add(manipulation.execute(dm));
+                            dm.getData().add(manipulation.execute(dm));
+                            
+                            // Need to update the metadata of the message
+                            dm.setMetadata(this.metadata);
+			}
+		}                
+		bus.post(message);
+                //System.out.println(Thread.currentThread());
+	}
+}

src/main/java/ch/psi/fda/aq/NotificationAgent.java

@@ -0,0 +1,109 @@
+/*
+ *  Copyright (C) 2011 Paul Scherrer Institute
+ * 
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ * 
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ * 
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package ch.psi.fda.aq;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.mail.Message;
+import javax.mail.MessagingException;
+import javax.mail.Session;
+import javax.mail.Transport;
+import javax.mail.internet.InternetAddress;
+import javax.mail.internet.MimeMessage;
+
+import ch.psi.fda.model.v1.Recipient;
+
+/**
+ * Agent to send out notifications to specified recipients.
+ */
+public class NotificationAgent {
+
+    private final static String smsPostfix = "@sms.switch.ch";
+
+    private Properties properties;
+    private String fromAddress;
+    private final List<Recipient> recipients = new ArrayList<Recipient>();
+
+    /**
+     * Constructor
+     * @param host		SMTP server to send notifications to
+     * @param recipients	List of recipients
+     * @param from		Address string that will show up in the from field. For example: fda@psi.ch. This argument must not contain white spaces
+     */
+    public NotificationAgent(String host, String from){
+
+        fromAddress = from;
+
+        properties = new Properties();
+        properties.put("mail.smtp.host", host);
+    }
+
+    
+    
+    public void sendNotification(String aSubject, String aBody, boolean error, boolean success) {
+
+        for(Recipient recipient: recipients){
+        	
+        	if((error && recipient.isError()) || (success && recipient.isSuccess())){
+	        	String receiver;
+	        	
+	        	// Verify mail recipients
+	            if(recipient.getValue().matches("[0-9,\\\\.,-,a-z,A-Z]*@[0-9,\\\\.,a-z,A-Z]*")){
+	                receiver = recipient.getValue();
+	            }
+	            else if(recipient.getValue().matches("[0-9]+")){
+	                // Assume that it is a SMS number
+	                receiver = recipient.getValue() + smsPostfix;
+	            }
+	            else{
+	                Logger.getLogger(NotificationAgent.class.getName()).log(Level.WARNING, "Invalid email address");
+	                continue;
+	            }
+	        	
+	        	
+	        	Logger.getLogger(NotificationAgent.class.getName()).log(Level.INFO, "Send notification to " + receiver);
+	        	
+	            //Here, no Authenticator argument is used (it is null).
+	            //Authenticators are used to prompt the user for user
+	            //name and password.
+	            Session session = Session.getDefaultInstance(properties, null);
+	            MimeMessage message = new MimeMessage(session);
+	            try {
+	                //The "from" address may be set in code, or set in the
+	                //config file under "mail.from" ; here, the latter style is used
+	                message.setFrom( new InternetAddress(fromAddress) );
+	
+	                message.addRecipient(Message.RecipientType.TO, new InternetAddress(receiver));
+	                message.setSubject(aSubject);
+	                message.setText(aBody);
+	                Transport.send(message);
+	            } catch (MessagingException ex) {
+	                Logger.getLogger(NotificationAgent.class.getName()).log(Level.WARNING, "Failed to send notification to " + receiver, ex);
+	            }
+        	}
+        }
+    }
+
+    public List<Recipient> getRecipients() {
+        return recipients;
+    }
+
+}

src/main/java/ch/psi/fda/aq/XScanContainer.java

@@ -0,0 +1,50 @@
+package ch.psi.fda.aq;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.EContainer;
+import ch.psi.fda.model.v1.Configuration;
+import ch.psi.jcae.ChannelService;
+
+public class XScanContainer implements EContainer {
+
+	private final Acquisition acquisition;
+	
+	private EventBus bus;
+	private Configuration xscanConfiguration;
+	
+	public XScanContainer(ChannelService cservice, AcquisitionConfiguration config, EventBus bus, Configuration xscanConfiguration){
+		acquisition = new Acquisition(cservice, config);
+		this.bus = bus;
+		this.xscanConfiguration = xscanConfiguration;
+	}
+	
+	@Override
+	public void initialize() {
+		acquisition.initalize(bus, xscanConfiguration);
+	}
+
+	@Override
+	public void execute() {
+		try {
+			acquisition.execute();
+		} catch (InterruptedException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	@Override
+	public void abort() {
+		acquisition.abort();
+	}
+
+	@Override
+	public void destroy() {
+		acquisition.destroy();
+	}
+
+	@Override
+	public boolean isActive() {
+		return acquisition.isActive();
+	}
+}

src/main/java/ch/psi/fda/aq/XScanDescriptor.java

@@ -0,0 +1,29 @@
+package ch.psi.fda.aq;
+
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+
+import ch.psi.fda.edescriptor.EDescriptor;
+import ch.psi.fda.model.v1.Configuration;
+
+@XmlRootElement(name="edescriptor")
+@XmlType(name="edescriptor")
+public class XScanDescriptor implements EDescriptor {
+
+	private Configuration configuration;
+
+	public XScanDescriptor(){
+	}
+	
+	public XScanDescriptor(Configuration configuration){
+		this.configuration = configuration;
+	}
+
+	
+	public Configuration getConfiguration() {
+		return configuration;
+	}
+	public void setConfiguration(Configuration configuration) {
+		this.configuration = configuration;
+	}
+}

src/main/java/ch/psi/fda/aq/XScanDescriptorProvider.java

@@ -0,0 +1,339 @@
+package ch.psi.fda.aq;
+
+import java.io.File;
+import java.util.List;
+import java.util.logging.Logger;
+
+import ch.psi.fda.DescriptorProvider;
+import ch.psi.fda.edescriptor.EDescriptor;
+import ch.psi.fda.model.ModelManager;
+import ch.psi.fda.model.v1.ArrayDetector;
+import ch.psi.fda.model.v1.Configuration;
+import ch.psi.fda.model.v1.ContinuousPositioner;
+import ch.psi.fda.model.v1.Data;
+import ch.psi.fda.model.v1.Detector;
+import ch.psi.fda.model.v1.LinearPositioner;
+import ch.psi.fda.model.v1.Positioner;
+import ch.psi.fda.model.v1.PseudoPositioner;
+import ch.psi.fda.model.v1.Visualization;
+import ch.psi.fda.vdescriptor.LinePlot;
+import ch.psi.fda.vdescriptor.VDescriptor;
+import ch.psi.fda.vdescriptor.XYSeries;
+import ch.psi.fda.vdescriptor.XYZSeries;
+import ch.psi.fda.vdescriptor.YSeries;
+import ch.psi.fda.vdescriptor.YZSeries;
+
+public class XScanDescriptorProvider implements DescriptorProvider {
+	
+	private static final Logger logger = Logger.getLogger(XScanDescriptorProvider.class.getName());
+
+	private EDescriptor edescriptor;
+	private VDescriptor vdescriptor;
+	
+	@Override
+	public void load(File... files) {
+		
+		if(files.length<1 || files[0]==null){
+			throw new IllegalArgumentException("There need to be at lease one file specified");
+		}
+		File file = files[0];
+		
+		if(!file.exists()){
+			throw new IllegalArgumentException("File "+file.getAbsolutePath()+" does not exist");
+		}
+		
+		Configuration c;
+		try {
+			c = ModelManager.unmarshall(file);
+		} catch (Exception e) {
+			throw new UnsupportedOperationException("Unable to deserialize configuration: "+e.getMessage(), e);
+		}
+		
+		// Set data file name
+		// Determine name used for the data file
+		String name = file.getName();
+		name = name.replaceAll("\\.xml$", "");
+		
+		if(c.getData()!=null){
+			Data data = c.getData();
+			// Only update filename if no name is specified in xml file
+			if(data.getFileName()==null){
+				data.setFileName(name);
+			}
+		}
+		else{
+			Data data = new Data();
+			data.setFileName(name);
+			c.setData(data);
+		}
+		
+		
+//		// Override number of executions
+//		if(iterations != null){
+//			c.setNumberOfExecution(iterations);
+//		}
+		// Fix configuration if iterations is specified with 0 and no iterations option is specified
+		if(c.getNumberOfExecution()==0){
+			c.setNumberOfExecution(1);
+		}
+		
+		this.edescriptor = new XScanDescriptor(c);
+		this.vdescriptor = mapVisualizations(c.getVisualization());
+		
+	}
+	
+	/**
+	 * Create a vdescriptor out of the scan description
+	 * @param vl
+	 * @return
+	 */
+	public static VDescriptor mapVisualizations(List<Visualization> vl){
+		VDescriptor vd = new VDescriptor();
+		
+		
+		for(Visualization v: vl){
+			if(v instanceof ch.psi.fda.model.v1.LinePlot){
+				ch.psi.fda.model.v1.LinePlot lp = (ch.psi.fda.model.v1.LinePlot) v;
+				
+				String x = getId(lp.getX());
+				
+				LinePlot lineplot = new LinePlot(lp.getTitle());
+				List<Object> l = lp.getY();
+				for(Object o: l){
+					String y = getId(o);
+					lineplot.getData().add(new XYSeries(x, y));
+				}
+				
+				vd.getPlots().add(lineplot);
+			}
+			else if(v instanceof ch.psi.fda.model.v1.LinePlotArray){
+				// Array visualization
+				ch.psi.fda.model.v1.LinePlotArray lp = (ch.psi.fda.model.v1.LinePlotArray) v;
+				
+				LinePlot lineplot = new LinePlot(lp.getTitle());
+				// Create data filter for visualization
+				List<Object> l = lp.getY();
+				for(Object o: l){
+					String idY = getId(o);
+					
+					// TODO Need to actually check if minX of 
+					lineplot.setMinX(new Double(lp.getOffset()));
+					lineplot.setMaxX(new Double(lp.getOffset()+lp.getSize()));
+                                        lineplot.setMaxSeries(lp.getMaxSeries());
+					lineplot.getData().add(new YSeries(idY));
+				}
+                                vd.getPlots().add(lineplot);
+			}
+			else if(v instanceof ch.psi.fda.model.v1.MatrixPlot){
+				
+				// MatrixPlot does currently not support RegionPositioners because of the
+				// plotting problems this would cause. If regions of the positioner have different
+				// step sizes it is not easily possible (without (specialized) rasterization) to plot the data.
+				
+				ch.psi.fda.model.v1.MatrixPlot mp = (ch.psi.fda.model.v1.MatrixPlot) v;
+				
+
+				double minX, maxX;
+				int nX;
+				double minY, maxY;
+				int nY;
+				
+				String idX, idY, idZ;
+				
+				// X Axis
+				if(mp.getX() instanceof LinearPositioner){
+					LinearPositioner linp = ((LinearPositioner)mp.getX());
+					idX = linp.getId();
+					
+					minX = (Math.min(linp.getStart(), linp.getEnd()));
+					maxX = (Math.max(linp.getStart(), linp.getEnd()));
+					nX = ((int) Math.floor((Math.abs(maxX-minX))/linp.getStepSize()) + 1);
+				}
+				else if(mp.getX() instanceof PseudoPositioner){
+					PseudoPositioner pp = ((PseudoPositioner)mp.getX());
+					idX = pp.getId();
+					minX = (1); // Count starts at 1
+					maxX = (pp.getCounts());
+					nX = (pp.getCounts());
+				}
+				else if(mp.getX() instanceof ContinuousPositioner){
+					ContinuousPositioner conp = ((ContinuousPositioner)mp.getX());
+					idX = conp.getId();
+					
+					minX = (Math.min(conp.getStart(), conp.getEnd()));
+					maxX = (Math.max(conp.getStart(), conp.getEnd()));
+					nX = ((int) Math.floor((Math.abs(maxX-minX))/conp.getStepSize()) + 1);
+				}
+				else{
+					// Fail as we cannot determine the min, max and number of steps
+					throw new RuntimeException(mp.getX().getClass().getName()+" is not supported as x-axis of a MatrixPlot");
+				}
+				
+				// Y Axis
+				if(mp.getY() instanceof LinearPositioner){
+					LinearPositioner linp = ((LinearPositioner)mp.getY());
+					idY = linp.getId();
+					minY = (Math.min(linp.getStart(), linp.getEnd()));
+					maxY = (Math.max(linp.getStart(), linp.getEnd()));
+					nY = ((int) Math.floor((Math.abs(maxY-minY))/linp.getStepSize()) + 1);
+				}
+				else if(mp.getY() instanceof PseudoPositioner){
+					PseudoPositioner pp = ((PseudoPositioner)mp.getY());
+					idY = pp.getId();
+					minY = (1); // Count starts at 1
+					maxY = (pp.getCounts());
+					nY = (pp.getCounts());
+				}
+				else{
+					// Fail as we cannot determine the min, max and number of steps
+					throw new RuntimeException(mp.getY().getClass().getName()+" is not supported as y-axis of a MatrixPlot");
+				}
+				
+				// Z Dimension
+				idZ = getId(mp.getZ());
+
+				
+				ch.psi.fda.vdescriptor.MatrixPlot matrixplot = new ch.psi.fda.vdescriptor.MatrixPlot(mp.getTitle());
+				matrixplot.setMinX(minX);
+				matrixplot.setMaxX(maxX);
+				matrixplot.setnX(nX);
+				matrixplot.setMinY(minY);
+				matrixplot.setMaxY(maxY);
+				matrixplot.setnY(nY);
+                                matrixplot.setType(mp.getType());
+				
+				matrixplot.getData().add(new XYZSeries(idX, idY, idZ));
+				vd.getPlots().add(matrixplot);
+			}
+			else if(v instanceof ch.psi.fda.model.v1.MatrixPlotArray){
+				// Support for 2D waveform plots
+				ch.psi.fda.model.v1.MatrixPlotArray mp = (ch.psi.fda.model.v1.MatrixPlotArray) v;
+				
+				// Get size of the array detector
+				int arraySize = 0;
+				Object o = mp.getZ();
+				if(o instanceof ArrayDetector){
+					ArrayDetector ad = (ArrayDetector) o;
+					arraySize = ad.getArraySize();
+				}
+				else{
+					// Workaround
+					arraySize = mp.getSize(); // of array is from a manipulation the size is not known. Then the size will indicate the size of the array to display
+				}
+				
+				int offset = mp.getOffset();
+				// Determine size for array
+				int size = mp.getSize();
+				if(size>0 && offset+size<arraySize){
+					size = mp.getSize();
+				}
+				else{
+					size=arraySize-offset;
+				}
+				
+				
+				double minY, maxY;
+				int nY;
+				
+				double minX = offset;
+				double maxX = offset+size-1;
+				int nX = size;
+				
+				String idY, idZ;
+				
+				// Y Axis
+				if(mp.getY() instanceof LinearPositioner){
+					LinearPositioner linp = ((LinearPositioner)mp.getY());
+					idY = linp.getId();
+					
+					minY = (Math.min(linp.getStart(), linp.getEnd()));
+					maxY = (Math.max(linp.getStart(), linp.getEnd()));
+					nY = ((int) Math.floor((Math.abs(maxY-minY))/linp.getStepSize()) + 1);
+				}
+				else if(mp.getY() instanceof PseudoPositioner){
+					PseudoPositioner pp = ((PseudoPositioner)mp.getY());
+					idY = pp.getId();
+					minY = (1); // Count starts at 1
+					maxY = (pp.getCounts());
+					nY = (pp.getCounts());
+				}
+				else if(mp.getY() instanceof ContinuousPositioner){
+					ContinuousPositioner conp = ((ContinuousPositioner)mp.getY());
+					idY = conp.getId();
+					
+					minY = (Math.min(conp.getStart(), conp.getEnd()));
+					maxY = (Math.max(conp.getStart(), conp.getEnd()));
+					nY = ((int) Math.floor((Math.abs(maxY-minY))/conp.getStepSize()) + 1);
+				}
+				else{
+					// Fail as we cannot determine the min, max and number of steps
+					throw new RuntimeException(mp.getY().getClass().getName()+" is not supported as x-axis of a MatrixPlot");
+				}
+				
+				
+				// Z Dimension
+				idZ = getId(mp.getZ());
+
+				ch.psi.fda.vdescriptor.MatrixPlot matrixplot = new ch.psi.fda.vdescriptor.MatrixPlot(mp.getTitle());
+				matrixplot.setMinX(minX);
+				matrixplot.setMaxX(maxX);
+				matrixplot.setnX(nX);
+				matrixplot.setMinY(minY);
+				matrixplot.setMaxY(maxY);
+				matrixplot.setnY(nY);
+                                matrixplot.setType(mp.getType());
+				
+				matrixplot.getData().add(new YZSeries(idY, idZ));
+				vd.getPlots().add(matrixplot);
+				
+			}
+			else{
+				logger.warning(v.getClass().getName()+" is not supported as visualization type");
+			}
+		}
+		return vd;
+	}
+	
+	/**
+	 * Retrieve id string of the passed object
+	 * @param object
+	 * @return	Id string of object
+	 */
+	private static String getId(Object object){
+		String id;
+		if(object instanceof Positioner){
+			id = ((Positioner)object).getId();
+		}
+		else if (object instanceof Detector){
+			id = ((Detector)object).getId();
+		}
+		else if (object instanceof ch.psi.fda.model.v1.Manipulation){
+			id = ((ch.psi.fda.model.v1.Manipulation)object).getId();
+		}
+		// For testing purposes
+		else if(object instanceof String){
+			id = (String) object;
+		}
+		else{
+			throw new RuntimeException("Unable to identify id of object reference "+object);
+		}
+		return id;
+	}
+	
+
+	@Override
+	public EDescriptor getEDescriptor() {
+		return edescriptor;
+	}
+
+	@Override
+	public VDescriptor getVDescriptor() {
+		return vdescriptor;
+	}
+
+	@Override
+	public Class<?> getEDescriptorClass() {
+		return XScanDescriptor.class;
+	}
+
+}

src/main/java/ch/psi/fda/aq/XScanFactory.java

@@ -0,0 +1,36 @@
+package ch.psi.fda.aq;
+
+import javax.inject.Inject;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.EContainer;
+import ch.psi.fda.EContainerFactory;
+import ch.psi.fda.edescriptor.EDescriptor;
+import ch.psi.jcae.ChannelService;
+
+public class XScanFactory implements EContainerFactory {
+
+	@Inject
+	private ChannelService cservice;
+	
+	private AcquisitionConfiguration config = new AcquisitionConfiguration();
+	
+	@Override
+	public boolean supportsEDescriptor(EDescriptor descriptor) {
+		return (descriptor instanceof XScanDescriptor);
+	}
+
+	@Override
+	public EContainer getEContainer(EDescriptor descriptor, EventBus bus) {
+		
+		if(! (descriptor instanceof XScanDescriptor)){
+			throw new IllegalArgumentException("Descriptor of type "+descriptor.getClass().getName()+" is not supported - descriptor need to be of type "+XScanDescriptor.class);
+		}
+		
+		XScanDescriptor xdescriptor = (XScanDescriptor) descriptor;
+		
+		return new XScanContainer(cservice, config, bus, xdescriptor.getConfiguration());
+	}
+
+}

src/main/java/ch/psi/fda/cdump/Cdump.java

@@ -0,0 +1,151 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This code is distributed in the hope that it will be useful, but without any
+ * warranty; without even the implied warranty of merchantability or fitness for
+ * a particular purpose. See the GNU Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.cdump;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelDescriptor;
+import ch.psi.jcae.ChannelException;
+import ch.psi.jcae.ChannelService;
+
+/**
+ * Cdump readout logic - i.e. put monitor on a data waveform channel of the fast
+ * ADC and send data to the eventbus
+ */
+public class Cdump {
+	
+	private static final Logger logger = Logger.getLogger(Cdump.class.getName());
+	
+	public final static String[] SAMPLING_RATES = new String[] {"1Hz","2Hz", "5Hz", "10Hz", "20Hz", "50Hz", "100Hz", "200Hz", "500Hz",
+		"1kHz", "2kHz", "5kHz", "10kHz", "20kHz", "50kHz", "100kHz"};
+	
+	private Channel<int[]> adcData;
+
+	private enum AdcCmd {
+		READY, GO
+	};
+
+	private Channel<Integer> adcCmd;
+
+	private CdumpListener listener;
+	private ChannelService cservice;
+	private CdumpConfiguration configuration;
+
+	public Cdump(ChannelService cservice, EventBus ebus, CdumpConfiguration configuration) {
+		this.cservice = cservice;
+		this.configuration = configuration;
+		this.listener = new CdumpListener(ebus, configuration.getNelements());
+	}
+
+	/**
+	 * Acquire data with the given sampling rate
+	 * @param samplingRate
+	 */
+	public void acquire(String samplingRate) {
+		
+		logger.info("Start acquisition with sampling rate "+ samplingRate);
+		
+		try {
+			// Set ADC sampling rate
+			Channel<Integer> smplRate = cservice.createChannel(new ChannelDescriptor<>(Integer.class, configuration.getSamplingRateChannel(), false));
+			smplRate.setValue(getIntSamplingRate(samplingRate));
+			smplRate.destroy();
+
+			adcData = cservice.createChannel(new ChannelDescriptor<>(int[].class, configuration.getDataChannel(), true));
+			adcCmd = cservice.createChannel(new ChannelDescriptor<>(Integer.class, configuration.getControlChannel(), false));
+
+			adcCmd.setValue(AdcCmd.GO.ordinal());
+			adcData.addPropertyChangeListener(listener);
+		} catch (ChannelException | TimeoutException | InterruptedException | ExecutionException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	/**
+	 * Wait until acquire is done
+	 */
+	public void waitAcquireDone(){
+		try {
+			adcCmd.waitForValue(AdcCmd.READY.ordinal());
+		} catch (InterruptedException | ExecutionException | ChannelException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	public void stop() {
+		
+		logger.info("Stop acquisition");
+		
+		try {
+			// Detach listener from channel - i.e. stop data acquisition
+			adcData.removePropertyChangeListener(listener);
+			adcCmd.setValue(AdcCmd.READY.ordinal());
+	
+			listener.terminate();
+		
+			adcCmd.destroy();
+			adcData.destroy();
+		} catch (ChannelException | InterruptedException | ExecutionException e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	/**
+	 * Get sampling rate int value based on the passed rate string.
+	 * If the string does not match any of the strings specified in the rates variable
+	 * this function will set the rate to 1Hz
+	 * 
+	 * 0  = 1Hz 
+	 * 1  = 2Hz
+	 * 2  = 5Hz
+	 * 3  = 10Hz
+	 * 4  = 20Hz
+	 * 5  = 50Hz
+	 * 6  = 100Hz
+	 * 7  = 200Hz
+	 * 8  = 500Hz
+	 * 9  = 1000Hz
+	 * 10 = 2000Hz
+	 * 11 = 5000Hz
+	 * 12 = 10000Hz
+	 * 13 = 20000Hz
+	 * 14 = 50000Hz
+	 * 15 = 100000Hz
+	 *  
+	 * @param rate
+	 */
+	private int getIntSamplingRate(String rate){
+		
+		for(int i=0;i<SAMPLING_RATES.length; i++){
+			if(rate.equals(SAMPLING_RATES[i])){
+				return i;
+			}
+		}
+		
+		// Default sampling rate 10kHz
+		logger.info("Using default sampling rate 12");
+		return 12;
+	}
+}

src/main/java/ch/psi/fda/cdump/CdumpConfiguration.java

@@ -0,0 +1,87 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.cdump;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.Properties;
+
+
+public class CdumpConfiguration {
+	
+	public final static String CDUMP_CONFIG = "ch.psi.fda.cdump.config.file";
+	
+	private String dataChannel;
+	private int nelements = 65536;
+	private String controlChannel;
+	private String samplingRateChannel;
+
+	public CdumpConfiguration(){
+		String config = System.getProperty(CDUMP_CONFIG);
+		
+		if(config != null){
+			loadFile(new File(config));
+		}
+		else{
+			throw new RuntimeException("No configuration file specified via -D"+CDUMP_CONFIG+"=...");
+		}
+	}
+
+	public void loadFile(File file) {
+		Properties properties = new Properties();
+		
+		if(file!=null){
+			try {
+				properties.load(new FileReader(file));
+			} catch (IOException e) {
+				throw new RuntimeException("Cannot read file "+file, e);
+			}
+		}
+		
+		dataChannel = properties.getProperty(CdumpConfiguration.class.getPackage().getName()+".dataChannel", "");
+		controlChannel = properties.getProperty(CdumpConfiguration.class.getPackage().getName()+".controlChannel", "");
+		samplingRateChannel = properties.getProperty(CdumpConfiguration.class.getPackage().getName()+".samplingRateChannel", "");
+		nelements = Integer.parseInt(properties.getProperty(CdumpConfiguration.class.getPackage().getName()+".nelements", "65536"));
+		
+	}
+	
+	public String getDataChannel() {
+		return dataChannel;
+	}
+	public void setDataChannel(String dataChannel) {
+		this.dataChannel = dataChannel;
+	}
+	public String getControlChannel() {
+		return controlChannel;
+	}
+	public void setControlChannel(String controlChannel) {
+		this.controlChannel = controlChannel;
+	}
+	public String getSamplingRateChannel() {
+		return samplingRateChannel;
+	}
+	public void setSamplingRateChannel(String samplingRateChannel) {
+		this.samplingRateChannel = samplingRateChannel;
+	}
+	public int getNelements() {
+		return nelements;
+	}
+}

src/main/java/ch/psi/fda/cdump/CdumpEContainer.java

@@ -0,0 +1,73 @@
+package ch.psi.fda.cdump;
+
+import java.io.File;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.EContainer;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.serializer.SerializerTXT;
+import ch.psi.jcae.ChannelService;
+
+public class CdumpEContainer implements EContainer {
+
+	private final ChannelService cservice;
+	private final CdumpEDescriptor edescriptor;
+	private final EventBus eventbus;
+
+	private Cdump cdump;
+	private SerializerTXT serializer;
+
+	private volatile boolean running = false;
+	
+	public CdumpEContainer(ChannelService cservice, EventBus eventbus, CdumpEDescriptor edescriptor) {
+		this.cservice = cservice;
+		this.eventbus = eventbus;
+		this.edescriptor = edescriptor;
+	}
+
+	@Override
+	public void initialize() {
+		cdump = new Cdump(cservice, eventbus, new CdumpConfiguration());
+
+		File file = new File(edescriptor.getFileName());
+		file.getParentFile().mkdirs(); // Create data base directory
+		
+		serializer = new SerializerTXT(file);
+		serializer.setShowDimensionHeader(false);
+
+		eventbus.register(serializer);
+	}
+
+	@Override
+	public void execute() {
+		running = true;
+		try{
+			cdump.acquire(edescriptor.getSamplingRate());
+			cdump.waitAcquireDone();
+		}
+		finally{
+			running=false;
+		}
+	}
+
+	@Override
+	public void abort() {
+		eventbus.post(new EndOfStreamMessage());
+		cdump.stop();
+		running = false;
+		
+		eventbus.unregister(serializer);
+	}
+
+	@Override
+	public boolean isActive() {
+		return running;
+	}
+
+	@Override
+	public void destroy() {
+		abort();
+	}
+
+}

src/main/java/ch/psi/fda/cdump/CdumpEContainerFactory.java

@@ -0,0 +1,26 @@
+package ch.psi.fda.cdump;
+
+import javax.inject.Inject;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.EContainer;
+import ch.psi.fda.EContainerFactory;
+import ch.psi.fda.edescriptor.EDescriptor;
+import ch.psi.jcae.ChannelService;
+
+public class CdumpEContainerFactory implements EContainerFactory {
+
+	@Inject
+	private ChannelService cservice;
+	
+	@Override
+	public boolean supportsEDescriptor(EDescriptor descriptor) {
+		return descriptor instanceof CdumpEDescriptor;
+	}
+
+	@Override
+	public EContainer getEContainer(EDescriptor descriptor, EventBus bus) {
+		return new CdumpEContainer(cservice, bus, (CdumpEDescriptor) descriptor);
+	}
+}

src/main/java/ch/psi/fda/cdump/CdumpEDescriptor.java

@@ -0,0 +1,25 @@
+package ch.psi.fda.cdump;
+
+import javax.xml.bind.annotation.XmlRootElement;
+
+import ch.psi.fda.edescriptor.EDescriptor;
+
+@XmlRootElement(name="cdump")
+public class CdumpEDescriptor implements EDescriptor {
+
+	private String samplingRate;
+	private String fileName;
+	
+	public String getSamplingRate() {
+		return samplingRate;
+	}
+	public void setSamplingRate(String samplingRate) {
+		this.samplingRate = samplingRate;
+	}
+	public String getFileName() {
+		return fileName;
+	}
+	public void setFileName(String fileName) {
+		this.fileName = fileName;
+	}
+}

src/main/java/ch/psi/fda/cdump/CdumpEDescriptorProvider.java

@@ -0,0 +1,44 @@
+package ch.psi.fda.cdump;
+
+import java.io.File;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+
+import ch.psi.fda.DescriptorProvider;
+import ch.psi.fda.edescriptor.EDescriptor;
+import ch.psi.fda.vdescriptor.VDescriptor;
+
+public class CdumpEDescriptorProvider implements DescriptorProvider {
+
+	private EDescriptor edescriptor;
+	
+	@Override
+	public void load(File... files) {
+		try {
+			JAXBContext context = JAXBContext.newInstance(CdumpEDescriptor.class);
+			Unmarshaller u = context.createUnmarshaller();
+			edescriptor = (EDescriptor) u.unmarshal(files[0]);
+		} catch (JAXBException e) {
+			throw new RuntimeException(e);
+		}
+		
+	}
+
+	@Override
+	public EDescriptor getEDescriptor() {
+		return edescriptor;
+	}
+
+	@Override
+	public VDescriptor getVDescriptor() {
+		return null;
+	}
+
+	@Override
+	public Class<?> getEDescriptorClass() {
+		return CdumpEDescriptor.class;
+	}
+
+}

src/main/java/ch/psi/fda/cdump/CdumpListener.java

@@ -0,0 +1,102 @@
+/**
+ * 
+ * Copyright 2013 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This code is distributed in the hope that it will be useful, but without any
+ * warranty; without even the implied warranty of merchantability or fitness for
+ * a particular purpose. See the GNU Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+package ch.psi.fda.cdump;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.ArrayList;
+import java.util.List;
+
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.messages.Metadata;
+
+import com.google.common.eventbus.EventBus;
+
+/**
+ * Listener that monitors the adc data channel and splitting up the data
+ */
+public class CdumpListener implements PropertyChangeListener {
+	
+	private final EventBus bus;
+	private final int numberOfElements;
+
+	private boolean first = true;
+	private int numberOfWaveforms = 0;
+	private final List<Metadata> metadata = new ArrayList<>();
+	
+	public CdumpListener(EventBus bus, int numberOfElements){
+		this.bus = bus;
+		this.numberOfElements = numberOfElements;
+	}
+	
+	@Override
+	public void propertyChange(PropertyChangeEvent evt) {
+		if(evt.getPropertyName().equals("value")){
+			transform((int[]) evt.getNewValue());
+		}
+	}
+	
+	
+	/**
+	 * Transform received waveform
+	 * 1. Take channel waveform
+	 * [wavefrom .......................................................]
+	 * 2. Split up waveform
+	 * [1-number of elements][2-number of elements][3-number of elements]
+	 * 3. Rotate splitted waveforms
+	 * [1-0,2-0,3-0]   thats one message
+	 * [1-1,2-1,3-1]
+	 * ...
+	 * [1-noe, 2-noe, 3-noe]
+	 * 
+	 */
+	public void transform(int[] value){
+		
+		// The first time check whether received waveform is a multiple of the specified number of elements number
+		// Calculate how many waveforms are within the received waveform
+		if(first){
+			first=false;
+			int nelements = value.length;
+			int n = nelements % numberOfElements;
+			if (n != 0) {
+				throw new RuntimeException("Array size is not a multiple of "+numberOfElements);
+			}
+			numberOfWaveforms = nelements / numberOfElements;
+			for(int i=0;i<numberOfWaveforms;i++){
+				metadata.add(new Metadata("waveform-"+i));
+			}
+		}
+		
+
+		// Split and rotate waveform
+		for (int x = 0; x < numberOfElements; x++) {
+			
+			DataMessage m = new DataMessage(metadata);
+			for (int t = 0; t < numberOfWaveforms; t++) {
+				m.getData().add(value[x + t * numberOfElements]);
+			}
+			bus.post(m);
+		}
+	}
+
+	public void terminate(){
+		bus.post(new EndOfStreamMessage());
+	}
+}

src/main/java/ch/psi/fda/cdump/ui/CdumpMain.java

@@ -0,0 +1,107 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.cdump.ui;
+
+import java.io.File;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import com.google.common.eventbus.AsyncEventBus;
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.cdump.Cdump;
+import ch.psi.fda.cdump.CdumpConfiguration;
+import ch.psi.fda.serializer.SerializerTXT;
+import ch.psi.jcae.ChannelService;
+import ch.psi.jcae.impl.DefaultChannelService;
+import sun.misc.Signal;
+import sun.misc.SignalHandler;
+
+@SuppressWarnings("restriction")
+public class CdumpMain {
+	
+	public static void main(String[] args){
+		
+		final ChannelService cservice = new DefaultChannelService();
+		
+		if(args.length != 2){
+			System.err.println("Usage: cdump <samplingRate> <datafilename>");
+			StringBuilder b = new StringBuilder();
+			for(String s: Cdump.SAMPLING_RATES){
+				b.append(s);
+				b.append(" ");
+			}
+			System.err.println("Supported rates: "+b.toString());
+			System.exit(1);
+		}
+		
+		String samplingRate = args[0];
+		
+		// Calculate data file location/name
+		String fname = args[1];
+		
+		File f = new File(fname);
+		f.getParentFile().mkdirs(); // Create data base directory
+		
+		// Create execution service
+		EventBus eventbus = new AsyncEventBus(Executors.newSingleThreadExecutor());
+		final Cdump service = new Cdump(cservice, eventbus, new CdumpConfiguration());
+		
+		SerializerTXT serializer = new SerializerTXT(f);
+		serializer.setShowDimensionHeader(false);
+		
+		eventbus.register(serializer);
+	
+		// Stop/abort handling of acquisition
+		Signal.handle(new Signal("INT"), new SignalHandler() {
+			/**
+			 * Thread save signal counter
+			 */
+			private AtomicInteger signalCount= new AtomicInteger(0);
+			
+			/**
+			 * Testing signal handler (in Eclipse) use this after starting scan:
+			 *
+			 * SL5: A=`ps -ef | tail -10 | grep jav[a] | awk '{printf $2}'`;kill -2 $A
+			 * MacOS X: A=`ps -ef | grep AcquisitionMai[n] | awk '{printf $2}'`;kill -2 $A
+			 * 
+			 * on the command line use CTRL-C
+			 */
+			@Override
+			public void handle(Signal signal) {
+				
+				
+				int count = signalCount.incrementAndGet();
+				
+				// If signal is received more than 1 time forcefully abort application
+				if(count>1){
+					System.exit(2);
+				}
+
+				service.stop();
+				
+				cservice.destroy();
+			}
+		});
+		
+		service.acquire(samplingRate);
+	}
+
+}

src/main/java/ch/psi/fda/core/Action.java

@@ -0,0 +1,33 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+public interface Action {
+	
+	/**
+	 * Execute logic of the action
+	 */
+	public void execute() throws InterruptedException;
+	
+	/**
+	 * Abort the execution logic of the action
+	 */
+	public void abort();
+}

src/main/java/ch/psi/fda/core/ActionLoop.java

@@ -0,0 +1,66 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+import java.util.List;
+
+import com.google.common.eventbus.EventBus;
+
+/**
+ * Loop of actions to accomplish a task. Depending on the loop
+ * actions may be executed in a different way.
+ */
+public interface ActionLoop extends Action {
+	
+	/**
+	 * Prepare ActionLoop for execution.
+	 */
+	public void prepare();
+	
+	/**
+	 * Cleanup resources used by this ActionLoop while it was executed.
+	 */
+	public void cleanup();
+	
+	/**
+	 * Get the pre actions of the Loop
+	 * @return	pre actions
+	 */
+	public List<Action> getPreActions();
+	
+	/**
+	 * Get the post actions of the loop
+	 * @return post actions
+	 */
+	public List<Action> getPostActions();
+	
+	/**
+	 * @return is a datagroup
+	 */
+	public boolean isDataGroup();
+
+	/**
+	 * Set whether data of the loop belongs to a own data group
+	 * @param dataGroup
+	 */
+	public void setDataGroup(boolean dataGroup);
+	
+	public EventBus getEventBus();
+}

src/main/java/ch/psi/fda/core/Actor.java

@@ -0,0 +1,49 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+public interface Actor {
+	/**
+	 * Set actor value
+	 */
+	public void set() throws InterruptedException;
+	
+	/**
+	 * Function to check whether the actor has a next set value
+	 * @return  Returns true if there is an actor value for the next iteration.
+	 * 			False if there is no actor value (i.e. this will be the last iteration in the ActionLoop)
+	 */
+	public boolean hasNext();
+	
+	/**
+	 * Initialize the actor to the start
+	 */
+	public void init();
+	
+	/**
+	 * Reverse the set values of the actor
+	 */
+	public void reverse();
+	
+	/**
+	 * Reset the actuator to its initial configuration
+	 */
+	public void reset();
+}

src/main/java/ch/psi/fda/core/ActorSetCallable.java

@@ -0,0 +1,40 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+import java.util.concurrent.Callable;
+
+/**
+ * Callable used for parallel execution of the set method of an actor
+ */
+public class ActorSetCallable implements Callable<Object> {
+
+	private Actor actor;
+	
+	public ActorSetCallable(Actor actor){
+		this.actor = actor;
+	}
+	
+	@Override
+	public Object call() throws Exception {
+		actor.set();
+		return null;
+	}
+}

src/main/java/ch/psi/fda/core/Guard.java

@@ -0,0 +1,41 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+/**
+ * Guard to protect specific activities. A guard can be used to check for environment changes while a
+ * certain activity was executed. 
+ * 
+ * Example:
+ * An Guard can be used to check whether an injection happened while the the detector were read. 
+ */
+public interface Guard {
+	
+	/**
+	 * Initialize guard object and its internal state.
+	 */
+	public void init();
+	
+	/**
+	 * Check the status of the guard.
+	 * @return	Returns true if the guard condition was not constrainted since the last init call. False otherwise.
+	 */
+	public boolean check();
+}

src/main/java/ch/psi/fda/core/Manipulation.java

@@ -0,0 +1,47 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+import java.util.List;
+
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.Metadata;
+
+public interface Manipulation {
+
+	/**
+	 * Get the id of the manipulation
+	 * @return	id of manipulation
+	 */
+	public String getId();
+	
+	/**
+	 * Initialize the manipulation
+	 * @param metadata	Metadata of the incomming data message
+	 */
+	public void initialize(List<Metadata> metadata);
+	
+	/**
+	 * Execute the manipulation on the passed data message
+	 * @param message Message to manipulate
+	 * @return	Result of the manipulation
+	 */
+	public Object execute(DataMessage message);
+}

src/main/java/ch/psi/fda/core/Sensor.java

@@ -0,0 +1,39 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core;
+
+/**
+ * The sensor interface describes an entity that can be read out like a
+ * simple channel or (image) detector. Depending on the sensor type the
+ * returned data is of a certain type.
+ */
+public interface Sensor {
+	/**
+	 * Readout sensor. 
+	 * @return	Sensor value. The type of the returned value depends on the sensor type.
+	 */
+	public Object read() throws InterruptedException;
+	
+	/**
+	 * Get the global id of the sensor
+	 * @return	id of sensor
+	 */
+	public String getId();
+}

src/main/java/ch/psi/fda/core/TestConfiguration.java

@@ -0,0 +1,87 @@
+/**
+ * 
+ * Copyright 2012 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This code is distributed in the hope that it will be useful, but without any
+ * warranty; without even the implied warranty of merchantability or fitness for
+ * a particular purpose. See the GNU Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+package ch.psi.fda.core;
+
+public class TestConfiguration {
+	private static final TestConfiguration instance = new TestConfiguration();
+	
+	private final String otfPrefix = "MTEST-HW3-OTFX";
+	private final String crlogicPrefix = "MTEST-HW3-CRL";
+	private final String prefixScaler = "MTEST-HW3:JS";
+	private final String server = "MTEST-VME-HW3";
+	
+	private final String motor1 = "MTEST-HW3:MOT1";
+	private final String analogIn1 = "MTEST-HW3-AI1:AI_01";
+	
+	private final String ioc = "MTEST-VME-HW3.psi.ch";
+	
+	private TestConfiguration(){
+	}
+	
+	public static TestConfiguration getInstance(){
+		return instance;
+	}
+
+	/**
+	 * @return the prefix
+	 */
+	public String getCrlogicPrefix() {
+		return crlogicPrefix;
+	}
+
+	/**
+	 * @return the prefixScaler
+	 */
+	public String getPrefixScaler() {
+		return prefixScaler;
+	}
+
+	/**
+	 * @return the server
+	 */
+	public String getServer() {
+		return server;
+	}
+
+	/**
+	 * @return the motor1
+	 */
+	public String getMotor1() {
+		return motor1;
+	}
+
+	/**
+	 * @return the analogIn1
+	 */
+	public String getAnalogIn1() {
+		return analogIn1;
+	}
+
+	/**
+	 * @return the otfPrefix
+	 */
+	public String getOtfPrefix() {
+		return otfPrefix;
+	}
+
+	public String getIoc() {
+		return ioc;
+	}
+	
+}

src/main/java/ch/psi/fda/core/actions/ChannelAccessCondition.java

@@ -0,0 +1,124 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actions;
+
+import java.util.Comparator;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Action;
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelException;
+
+/**
+ * Perform a put on the specified Channel Access channel. The put can be done synchronous or
+ * asynchronously.
+ */
+public class ChannelAccessCondition<E> implements Action {
+
+	private static Logger logger = Logger.getLogger(ChannelAccessCondition.class.getName());
+	
+	private final Channel<E> channel;
+	private final E expectedValue;
+	private final Comparator<E> comparator;
+	private final Long timeout;
+	
+	private volatile boolean abort = false;
+	private volatile Thread waitT = null;
+	
+	/**
+	 * @param channel		Channel to wait value for
+	 * @param expectedValue		Value to wait for
+	 * @param timeout			Timeout of the condition in milliseconds (null accepted - will take default wait timeout for channels ch.psi.jcae.ChannelBeanFactory.waitTimeout)
+	 * 
+	 * @throws	IllegalArgumentException	Timeout specified is not >=0
+	 */
+	public ChannelAccessCondition(Channel<E> channel, E expectedValue, Long timeout){
+
+		if(timeout != null && timeout<=0){
+			throw new IllegalArgumentException("Timeout must be > 0");
+		}
+		
+		this.channel = channel;
+		this.expectedValue = expectedValue;
+		this.comparator = null;
+		this.timeout = timeout;
+	}
+	
+	public ChannelAccessCondition(Channel<E> channel, E expectedValue, Comparator<E> comparator, Long timeout){
+
+		if(timeout != null && timeout<=0){
+			throw new IllegalArgumentException("Timeout must be > 0");
+		}
+		
+		this.channel = channel;
+		this.expectedValue = expectedValue;
+		this.comparator = comparator;
+		this.timeout = timeout;
+	}
+
+	
+	/**
+	 * @throws RuntimeException		Channel value did not reach expected value (within the specified timeout period)
+	 */
+	@Override
+	public void execute() throws InterruptedException {
+		abort=false;
+		logger.finest("Checking channel "+channel.getName()+" for value "+expectedValue+" [timeout: "+timeout+"]" );
+		try{
+			waitT = Thread.currentThread();
+			try {
+				if(comparator==null){
+					if(timeout == null){
+						channel.waitForValue(expectedValue);
+					}
+					else{
+						channel.waitForValue(expectedValue, timeout);
+					}
+				}
+				else{
+					if(timeout == null){
+						channel.waitForValue(expectedValue, comparator);
+					}
+					else{
+						channel.waitForValue(expectedValue, comparator, timeout);
+					}
+				}
+			} catch (ExecutionException | ChannelException | TimeoutException | InterruptedException e) {
+				if(abort && e instanceof InterruptedException){
+					return;
+				}
+				throw new RuntimeException("Channel [name:"+channel.getName()+"] did not reach expected value "+expectedValue+" ", e);
+			}
+		}
+		finally{
+			waitT=null;
+		}
+	}
+
+	@Override
+	public void abort() {
+		abort=true;
+		if(waitT!=null){
+			waitT.interrupt();
+		}
+	}
+}

src/main/java/ch/psi/fda/core/actions/ChannelAccessPut.java

@@ -0,0 +1,94 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actions;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Action;
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelException;
+
+/**
+ * Perform a put on the specified Channel Access channel. The put can be done synchronous or
+ * asynchronously.
+ */
+public class ChannelAccessPut<E> implements Action {
+	
+	private static Logger logger = Logger.getLogger(ChannelAccessPut.class.getName());
+
+	private final Channel<E> channel;
+	private final E value;
+	private final boolean asynchronous;
+	
+	private final Long timeout;
+	
+	/**
+	 * @param channel
+	 * @param value				Value to set
+	 * @param asynchronous		Flag whether to set the value synchronous (wait for response) or asynchronously (fire and forget)
+	 * @param timeout			Timeout used for set operation (time that set need to come back)
+	 */
+	public ChannelAccessPut(Channel<E> channel, E value, boolean asynchronous, Long timeout){
+
+		this.channel = channel;
+		this.value = value;
+		this.asynchronous = asynchronous;
+		this.timeout = timeout;
+	}
+	
+	/**
+	 * Additional constructor for convenience. This constructor defaults the operation type to synchronous put.
+	 * @param channel
+	 * @param value				Value to set
+	 */
+	public ChannelAccessPut(Channel<E> channel, E value){
+		this(channel, value, false, null);
+	}
+	
+	/**
+	 * @throws RuntimeException		Cannot set value on channel
+	 */
+	@Override
+	public void execute() throws InterruptedException {
+		logger.finest("Put to channel: "+channel.getName()+ " asynchronous: "+asynchronous);
+		try{
+			if(asynchronous){
+				channel.setValueNoWait(value);
+			}
+			else{
+				if(timeout==null){
+					channel.setValue(value);
+				}
+				else{
+					channel.setValueAsync(value).get(timeout, TimeUnit.MILLISECONDS);
+				}
+			}
+		} catch (ExecutionException | TimeoutException | ChannelException e) {
+			throw new RuntimeException("Unable to set channel [name:"+channel.getName()+"] to value "+value, e);
+		}
+	}
+
+	@Override
+	public void abort() {
+	}
+}

src/main/java/ch/psi/fda/core/actions/Delay.java

@@ -0,0 +1,52 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actions;
+
+import ch.psi.fda.core.Action;
+
+/**
+ * Wait a specific time until executing the next action ...
+ */
+public class Delay implements Action {
+
+	private final long time;
+	
+	/**
+	 * @param time		Time to wait in milliseconds
+	 */
+	public Delay(long time){
+		
+		// Check if delay time is positive and >0
+		if(time<=0){
+			throw new IllegalArgumentException("Wait time must be >0");
+		}
+		
+		this.time = time;
+	}
+	
+	@Override
+	public void execute() throws InterruptedException {
+		Thread.sleep(time);
+	}
+
+	@Override
+	public void abort() {
+	}
+}

src/main/java/ch/psi/fda/core/actions/JythonAction.java

@@ -0,0 +1,142 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actions;
+
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+
+import ch.psi.fda.core.Action;
+
+/**
+ * Executes a python script inside a Jython interpreter
+ */
+public class JythonAction implements Action {
+
+	private static Logger logger = Logger.getLogger(JythonAction.class.getName());
+	
+	/**
+	 * Pattern of the entry function of the jython script
+	 */
+	private static final String entryFunction = "process";
+	private static final String entryFunctionPattern = "def "+entryFunction+"\\((.*)\\):";
+	
+	private ScriptEngine engine;
+	
+	private String jythonCall; // entry call to script - including all parameters, etc.
+	
+	private final Map<String,Object> globalObjects;
+	
+	public JythonAction(String script, Map<String, ?> mapping){
+		this(script, mapping, new HashMap<String,Object>());
+	}
+	
+	public JythonAction(String script, Map<String, ?> mapping, Map<String,Object> globalObjects){
+		
+		this.globalObjects = globalObjects;
+		
+		// Workaround for Jython memory leak 
+		// http://blog.hillbrecht.de/2009/07/11/jython-memory-leakout-of-memory-problem/
+		System.setProperty("python.options.internalTablesImpl","weak");
+		
+		// Create new script engine
+		this.engine = new ScriptEngineManager().getEngineByName("python");
+		
+		// Determine script entry function and the function parameters
+		Pattern pattern = Pattern.compile(entryFunctionPattern);
+		Matcher matcher = pattern.matcher(script);
+		String[] functionParameters = null;
+		if(matcher.find() && matcher.groupCount()==1){
+			logger.finest("Entry function '"+entryFunctionPattern+"' found - Identified parameters: "+matcher.group(1));
+			jythonCall = entryFunction+"("+matcher.group(1)+")";
+			if(matcher.group(1).matches(" *")){
+				functionParameters = new String[0];
+			}
+			else{
+				functionParameters = matcher.group(1).split(" *, *");
+			}
+		}
+		else{
+			throw new IllegalArgumentException("Cannot determine entry function: "+entryFunctionPattern);
+		}
+		
+		// Check whether all function parameters have a mapping
+		for(int i=0;i<functionParameters.length; i++){
+			String p = functionParameters[i];
+			p = p.trim();
+			boolean found = false;
+			for(String pm: mapping.keySet()){
+				if(pm.equals(p)){
+					found=true;
+					break;
+				}
+			}
+			if(!found){
+				throw new IllegalArgumentException("No mapping compontent found for parameter "+p);
+			}
+		}
+		
+		// Check whether more mappings are specified than function parameters
+		if(functionParameters.length<mapping.size()){
+			throw new IllegalArgumentException("More mappings than function parameters are specified");
+		}
+		
+		// Load manipulation script
+		try {
+			engine.eval(script);
+		} catch (ScriptException e) {
+			throw new RuntimeException("Unable to load manipulation script", e);
+		}
+		
+		for(String b: mapping.keySet()){
+			// Assign channel bean to variable
+			engine.put(b, mapping.get(b));
+		}
+	}
+	
+	@Override
+	public void execute() {
+		
+		// Set global objects
+		// This block is not in initialization as we want to assure that all invocations
+		// of this manipulation will get the same value (i.e. to prevent inconsistent behavior
+		// if variable was changed during an execution of the manipulation)
+		for(String k: globalObjects.keySet()){
+			engine.put(k, globalObjects.get(k));
+		}
+		
+		try {
+			engine.eval(jythonCall+"\n");
+		} catch (ScriptException e) {
+			throw new RuntimeException("Action failed while executing the Jython script",e);
+		}		
+	}
+
+	@Override
+	public void abort() {
+	}
+}

src/main/java/ch/psi/fda/core/actions/ShellAction.java

@@ -0,0 +1,133 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actions;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Action;
+
+/**
+ * Action that executes a specified command when it is executed.
+ */
+public class ShellAction implements Action{
+	
+	private static Logger logger = Logger.getLogger(ShellAction.class.getName());
+
+	private volatile Process process;
+	private volatile boolean abort = false;
+	private boolean checkExitValue = true;
+	private int exitValue = 0;
+	
+	/**
+	 * Name (full path if it is not in the system path) of the script to execute when
+	 * the execute() function of this action is invoked.
+	 */
+	private final String script;
+	
+	/**
+	 * @param script	Name of the command to execute when this action is invoked
+	 * 
+	 * @throws IllegalArgumentException		Specified script does not exist
+	 */
+	public ShellAction(String script){
+		String[] scri = script.split("[ ,\t]");
+		File s = new File(scri[0]);
+		if(!s.exists()){
+			throw new IllegalArgumentException("Script "+script+" does not exist.");
+		}
+		this.script = script;
+	}
+	
+	@Override
+	public void execute() throws InterruptedException {
+		try{
+			abort = false;
+			logger.fine("Execute script "+script);
+			process = Runtime.getRuntime().exec(new String[]{"/bin/bash","-c",script});
+			int exitVal = process.waitFor();
+			
+			// Log output of the shell script if loglevel is finest
+			if(logger.isLoggable(Level.FINEST)){
+				logger.finest("STDOUT [BEGIN]");
+				// Ideally the readout of the stream should be in parallel to the processing of the script! I.e. the output appears in the log as it is generated by the script!
+				BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
+				String line = null;
+				while((line=reader.readLine()) != null){
+					logger.finest(line);
+				}
+				logger.finest("STDOUT [END]");
+				
+				logger.finest("STDERR [BEGIN]");
+				// Ideally the readout of the stream should be in parallel to the processing of the script! I.e. the output appears in the log as it is generated by the script!
+				reader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
+				line = null;
+				while((line=reader.readLine()) != null){
+					logger.finest(line);
+				}
+				logger.finest("STDERR [END]");
+			}
+			
+			logger.fine("Script ["+script+"] return value: "+exitVal);
+			
+			if(abort){
+				throw new RuntimeException("Script ["+script+"] was aborted");
+			}
+			else{
+				// Check script exit value to 0 if != 0 then throw an runtime exception
+				if(checkExitValue && exitVal != exitValue){
+					throw new RuntimeException("Script ["+script+"] returned with an exit value not equal to 0");
+				}
+			}
+			process = null;
+		}
+		catch(IOException e){
+			throw new RuntimeException("Unable to execute script: "+script,e);
+		}
+	}
+
+	@Override
+	public void abort() {
+		abort=true;
+		if(process!=null){
+			process.destroy();
+		}
+	}
+
+	public boolean isCheckExitValue() {
+		return checkExitValue;
+	}
+
+	public void setCheckExitValue(boolean checkExitValue) {
+		this.checkExitValue = checkExitValue;
+	}
+
+	public int getExitValue() {
+		return exitValue;
+	}
+
+	public void setExitValue(int exitValue) {
+		this.exitValue = exitValue;
+	}	
+}

src/main/java/ch/psi/fda/core/actors/ChannelAccessFunctionActuator.java

@@ -0,0 +1,253 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Actor;
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelException;
+
+public class ChannelAccessFunctionActuator<T> implements Actor {
+	
+	private static Logger logger = Logger.getLogger(ChannelAccessFunctionActuator.class.getName());
+
+	private boolean asynchronous = false;
+	private double start;
+	private double end;
+	private double stepSize;
+	private int direction; // Move direction (start&lt;end = 1, start&gt;end = -1)
+	
+	/**
+	 * Execution count of actuator. This variable is used to minimize the floating point
+	 * rounding errors for calculating the next step. 
+	 */
+	private int count;
+	
+	/**
+	 * Flag that indicates whether there is a next set value for the Actor
+	 */
+	private boolean next;
+	
+	/**
+	 * Value to set at next @see ch.psi.fda.engine.Actor#set() call
+	 */
+	private double value;
+	
+	/**
+	 * Level of accuracy the positioner need to have (e.g. if a positioner is set to 1 the readback set value
+	 * of the positioner need to have at lease 1+/-accuracy) 
+	 * Default is stepSize/2 
+	 */
+	private double accuracy;
+	
+	/**
+	 * Move timeout
+	 */
+	private Long timeout;
+	
+	private final T doneValue;
+	private final long doneDelay;
+	
+	private final double originalStart;
+	private final double originalEnd;
+	private final int originalDirection;
+	
+	private Channel<Double> channel;
+	private Channel<T> doneChannel = null;
+	
+	private final Function function;
+	private boolean checkActorSet = true;
+	
+	/**
+	 * Constructor - Initialize actor
+	 * @param channelName
+	 * @param start
+	 * @param end
+	 * @param stepSize
+	 * @param timeout 	Maximum move time (in milliseconds)
+	 */
+	public ChannelAccessFunctionActuator(Channel<Double> channel, Function function, double start, double end, double stepSize, Long timeout){
+		this(channel, null, null, 0, function, start, end, stepSize, timeout);
+	}
+	
+	/**
+	 * Constructor
+	 * @param channel
+	 * @param doneChannel	If null actor will not wait (for this channel) to continue
+	 * @param doneValue
+	 * @param doneDelay			Delay in seconds before checking the done channel
+	 * @param start
+	 * @param end
+	 * @param stepSize
+	 * @param timeout			Maximum move time (in milliseconds)
+	 */
+	public ChannelAccessFunctionActuator(Channel<Double> channel, Channel<T> doneChannel, T doneValue, double doneDelay,  Function function, double start, double end, double stepSize, Long timeout){
+		
+		this.doneValue = doneValue;
+		this.doneDelay = (long) Math.floor((doneDelay*1000));
+		this.start = start;
+		this.end = end;
+		
+		if(stepSize <= 0){
+			throw new IllegalArgumentException("Step size ["+stepSize+"] must be > 0");
+		}
+		this.stepSize = stepSize;
+		
+		this.accuracy = stepSize/2;
+		
+		// Validate and save timeout parameter
+		if(timeout!=null && timeout<=0){
+			throw new IllegalArgumentException("Timeout must be >0 or null");
+		}
+		else{
+			this.timeout = timeout;
+		}
+		
+		if(function==null){
+			throw new IllegalArgumentException("Function must not be null");
+		}
+		this.function = function;
+		
+		
+		init();
+		
+		// Save original settings
+		this.originalStart = start;
+		this.originalEnd = end;
+		this.originalDirection = direction;
+		
+		this.channel = channel;
+		this.doneChannel = doneChannel;
+	}
+	
+	@Override
+	public void set() throws InterruptedException {
+		
+		// Throw an IllegalStateException in the case that set is called although there is no next step.
+		if(!next){
+			throw new IllegalStateException("The actuator does not have any next step.");
+		}
+		
+		// Set actuator channel
+		logger.finest("Set actuator channel "+channel.getName()+" to value: "+value);
+		try {
+			double fvalue = function.calculate(value);
+			
+			if(!asynchronous){
+				if(timeout==null){
+					channel.setValue(fvalue);
+				}
+				else{
+					channel.setValueAsync(fvalue).get(timeout, TimeUnit.MILLISECONDS); 
+				}
+			}
+			else{
+				channel.setValueNoWait(fvalue);
+			}
+			
+			if(doneChannel != null){
+				Thread.sleep(doneDelay);
+				doneChannel.waitForValue(doneValue); 
+			}
+			
+			// Check whether the set value is really on the value that was set before.
+			if(checkActorSet){
+				double c = channel.getValue(true);
+				double a = Math.abs( c - fvalue ); 
+				if ( a > accuracy ){
+					throw new RuntimeException("Actor could not be set to the value "+fvalue+" The readback of the set value does not match the value that was set [value: "+c+" delta: "+a+" accuracy: "+accuracy+"]");
+				}
+			}
+			
+		} catch (ExecutionException | TimeoutException | ChannelException e) {
+			throw new RuntimeException("Unable to move actuator [channel: "+channel.getName()+"] to value "+value,e);
+		}
+		
+		
+		count++;
+		double nextValue = start+(count*stepSize*direction); // Done like this to keep floating point rounding errors minimal
+		
+		if((direction==1&&nextValue<=end)||(direction==-1&nextValue>=end)){
+			
+			// Apply function
+//			nextValue = function.calculate(nextValue);
+			
+			logger.fine("Next actor value: "+nextValue);
+			value=nextValue;
+			this.next = true;
+		}
+		else{
+			// There is no next set value
+			this.next = false;
+		}
+	}
+
+	@Override
+	public boolean hasNext() {
+		return next;
+	}
+
+	@Override
+	public void init() {
+		this.count = 0;
+		
+		// Determine move direction
+		this.direction = 1;
+		if(start>end){
+			direction=-1; // Move in negative direction
+		}
+
+		// Set first set value to the start value
+		this.value = start;
+		this.next = true;
+	}
+
+	@Override
+	public synchronized void reverse() {
+		double oldStart = start;
+		this.start = this.end;
+		this.end = oldStart;
+		
+		// Determine move direction
+		this.direction = 1;
+		if(this.start>this.end){
+			direction=-1; // Move in negative direction
+		}
+		
+	}
+
+	@Override
+	public void reset() {
+		this.start = this.originalStart;
+		this.end = this.originalEnd;
+		this.direction = this.originalDirection;
+	}
+
+	public boolean isAsynchronous() {
+		return asynchronous;
+	}
+	public void setAsynchronous(boolean asynchronous) {
+		this.asynchronous = asynchronous;
+	}
+}

src/main/java/ch/psi/fda/core/actors/ChannelAccessLinearActuator.java

@@ -0,0 +1,234 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Actor;
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelException;
+
+/**
+ * This actuator sets an Channel Access channel from a start to an end value by doing discrete steps.
+ */
+public class ChannelAccessLinearActuator<T> implements Actor {
+	
+	private static Logger logger = Logger.getLogger(ChannelAccessLinearActuator.class.getName());
+
+	private boolean asynchronous = false;
+	
+	private double start;
+	private double end;
+	private double stepSize;
+	private int direction;
+	
+	/**
+	 * Execution count of actuator. This variable is used to minimize the floating point
+	 * rounding errors for calculating the next step. 
+	 */
+	private int count;
+	
+	/**
+	 * Flag that indicates whether there is a next set value for the Actor
+	 */
+	private boolean next;
+	
+	/**
+	 * Value to set at next @see ch.psi.fda.engine.Actor#set() call
+	 */
+	private double value;
+	
+	/**
+	 * Level of accuracy the positioner need to have (e.g. if a positioner is set to 1 the readback set value
+	 * of the positioner need to have at lease 1+/-accuracy) 
+	 * Default is stepSize/2 
+	 */
+	private double accuracy;
+	
+	
+	
+	private final T doneValue;
+	private final long doneDelay;
+	
+	private final double originalStart;
+	private final double originalEnd;
+	private final int originalDirection;
+	
+	private Long timeout; // Set timeout
+	
+	private final Channel<Double> channel;
+	private final Channel<T> doneChannel;
+	
+	private boolean checkActorSet = true;
+	
+	/**
+	 * Constructor
+	 * @param channel
+	 * @param doneChannel	If null actor will not wait (for this channel) to continue
+	 * @param doneValue
+	 * @param doneDelay			Delay in seconds before checking the done channel
+	 * @param start
+	 * @param end
+	 * @param stepSize
+	 * @param timeout			Maximum move time (in milliseconds)
+	 */
+	public ChannelAccessLinearActuator(Channel<Double> channel, Channel<T> doneChannel, T doneValue, double doneDelay,  double start, double end, double stepSize, Long timeout){
+		
+		this.doneValue = doneValue;
+		this.doneDelay = (long) Math.floor((doneDelay*1000));
+		this.start = start;
+		this.end = end;
+		
+		if(stepSize <= 0){
+			throw new IllegalArgumentException("Step size ["+stepSize+"] must be > 0");
+		}
+		this.stepSize = stepSize;
+		
+		this.accuracy = stepSize/2;
+		
+		// Validate and save timeout parameter
+		if(timeout!=null && timeout<=0){
+			throw new IllegalArgumentException("Timeout must be >0 or null");
+		}
+		else{
+			this.timeout = timeout;
+		}
+		
+		
+		init();
+		
+		// Save original settings
+		this.originalStart = start;
+		this.originalEnd = end;
+		this.originalDirection = direction;
+		
+		this.channel = channel;
+		this.doneChannel = doneChannel;
+	}
+	
+	@Override
+	public void set() throws InterruptedException {
+		
+		// Throw an IllegalStateException in the case that set is called although there is no next step.
+		if(!next){
+			throw new IllegalStateException("The actuator does not have any next step.");
+		}
+		
+		// Set actuator channel
+		logger.finest("Set actuator channel "+channel.getName()+" to value: "+value);
+		try {
+			
+			if(!asynchronous){
+				if(timeout==null){
+					channel.setValue(value);
+				}
+				else{
+					channel.setValueAsync(value).get(timeout, TimeUnit.MILLISECONDS); 
+				}
+			}
+			else{
+				channel.setValueNoWait(value);
+			}
+			
+			if(doneChannel != null){
+				Thread.sleep(doneDelay);
+				doneChannel.waitForValue(doneValue); 
+			}
+			
+			// Check whether the set value is really on the value that was set before.
+			if(checkActorSet){
+				double c = channel.getValue(true);
+				double a = Math.abs( c - value ); 
+				if ( a > accuracy ){
+					throw new RuntimeException("Actor could not be set to the value "+value+" The readback of the set value does not match the value that was set [value: "+c+" delta: "+a+" accuracy: "+accuracy+"]");
+				}
+			}
+			
+		} catch (ExecutionException | TimeoutException | ChannelException e) {
+			throw new RuntimeException("Unable to move actuator [channel: "+channel.getName()+"] to value "+value,e);
+		}
+		
+		
+		count++;
+		double nextValue = start+(count*stepSize*direction); // Done like this to keep floating point rounding errors minimal
+		
+		if((direction==1&&nextValue<=end)||(direction==-1&nextValue>=end)){
+			logger.fine("Next actor value: "+nextValue);
+			value=nextValue;
+			this.next = true;
+		}
+		else{
+			// There is no next set value
+			this.next = false;
+		}
+	}
+
+	@Override
+	public boolean hasNext() {
+		return next;
+	}
+
+	@Override
+	public void init() {
+		this.count = 0;
+		
+		// Determine move direction
+		this.direction = 1;
+		if(start>end){
+			direction=-1; // Move in negative direction
+		}
+		
+		
+		// Set first set value to the start value
+		this.value = start;
+		this.next = true;
+	}
+
+	@Override
+	public synchronized void reverse() {
+		double oldStart = start;
+		this.start = this.end;
+		this.end = oldStart;
+		
+		// Determine move direction
+		this.direction = 1;
+		if(this.start>this.end){
+			direction=-1; // Move in negative direction
+		}
+		
+	}
+
+	@Override
+	public void reset() {
+		this.start = this.originalStart;
+		this.end = this.originalEnd;
+		this.direction = this.originalDirection;
+	}
+
+	public boolean isAsynchronous() {
+		return asynchronous;
+	}
+	public void setAsynchronous(boolean asynchronous) {
+		this.asynchronous = asynchronous;
+	}
+}

src/main/java/ch/psi/fda/core/actors/ChannelAccessTableActuator.java

@@ -0,0 +1,236 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Actor;
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelException;
+
+/**
+ * This actuator sets an Channel Access channel by using the positions from the given table.
+ */
+public class ChannelAccessTableActuator<T> implements Actor {
+	
+	private static Logger logger = Logger.getLogger(ChannelAccessTableActuator.class.getName());
+
+	private boolean asynchronous = false;
+	
+	/**
+	 * Position table
+	 */
+	private final double[] table;
+	
+	/**
+	 * Level of accuracy the positioner need to have (e.g. if a positioner is set to 1 the readback set value
+	 * of the positioner need to have at lease 1+/-accuracy)
+	 */
+	private double accuracy = 0.1;
+	
+	/**
+	 * Execution count of actuator. This variable is used to minimize the floating point
+	 * rounding errors for calculating the next step. 
+	 */
+	private int count;
+	
+	/**
+	 * Flag that indicates whether there is a next set value for the Actor
+	 */
+	private boolean next;
+
+	
+	private Channel<Double> channel;
+	private Channel<T> doneChannel = null;
+	
+	private final T doneValue;
+	private final long doneDelay;
+	
+	/**
+	 * Flag that indicates whether the actor moves in the positive direction 
+	 */
+	private boolean positiveDirection = true;
+	private final boolean originalPositiveDirection;
+	
+	/**
+	 * Maximum move time (in milliseconds)
+	 */
+	private Long timeout = null;
+	
+	private boolean checkActorSet = true;
+	
+	/**
+	 * Constructor - Initialize actor
+	 * @param channelName	Name of the channel to set
+	 * @param table			Position table with the explicit positions for each step
+	 * @param timeout		Maximum move time (in milliseconds)
+	 */
+	public ChannelAccessTableActuator(Channel<Double> channel, double[] table, Long timeout){
+		this(channel, null, null, 0, table, timeout);
+	}
+	
+	/**
+	 * Constructor
+	 * @param channel
+	 * @param doneChannel
+	 * @param doneValue
+	 * @param doneDelay
+	 * @param table
+	 * @param timeout		Maximum move time (in milliseconds)
+	 */
+	public ChannelAccessTableActuator(Channel<Double> channel, Channel<T> doneChannel, T doneValue, double doneDelay, double[] table, Long timeout){
+		
+		this.doneValue = doneValue;
+		this.doneDelay = (long) Math.floor((doneDelay*1000));
+		
+		if(table==null){
+			throw new IllegalArgumentException("Null table is not accepted");
+		}
+		if(table.length==0){
+			throw new IllegalArgumentException("Position table need to have at least one position");
+		}
+		
+		this.table = table;
+		
+		// Validate and save timeout parameter
+		if(timeout!=null && timeout<=0){
+			throw new IllegalArgumentException("Timeout must be >0 or null");
+		}
+		else{
+			this.timeout = timeout;
+		}
+		
+		init();
+		
+		// Save the initial direction
+		this.originalPositiveDirection = positiveDirection;
+		
+		this.channel = channel;
+		this.doneChannel = doneChannel;
+	}
+	
+	@Override
+	public void set() throws InterruptedException {
+		
+		// Throw an IllegalStateException in the case that set is called although there is no next step.
+		if(!next){
+			throw new IllegalStateException("The actuator does not have any next step.");
+		}
+		
+		// Set actuator channel
+		logger.finest("Set actuator channel "+channel.getName()+" to value: "+table[count]);
+		try {
+			if(!asynchronous){
+				if(timeout==null){
+					channel.setValue(table[count]);
+				}
+				else{
+					channel.setValueAsync(table[count]).get(timeout, TimeUnit.MILLISECONDS);
+				}
+			}
+			else{
+				channel.setValueNoWait(table[count]);
+			}
+			
+			
+			if(doneChannel != null){
+				Thread.sleep(doneDelay);
+				doneChannel.waitForValue(doneValue); 
+			}
+			
+			// Check whether the set value is really on the value that was set before.
+			if(doneChannel==null && !asynchronous && checkActorSet){
+				if ( Math.abs( channel.getValue() - table[count] ) > accuracy ){
+					throw new RuntimeException("Actor could not be set to the value "+table[count]+" The readback of the set value does not match the value that was set");
+				}
+			}
+			
+		} catch (ExecutionException | ChannelException | TimeoutException e) {
+			throw new RuntimeException("Move actuator [channel: "+channel.getName()+"] to value "+table[count],e);
+		}
+		
+		if(positiveDirection){
+			count++;
+			if(count<table.length){
+				this.next = true;
+			}
+			else{
+				// There is no next set value
+				this.next = false;
+			}
+		}
+		else{
+			count--;
+			if(count>=0){
+				this.next = true;
+			}
+			else{
+				// There is no next set value
+				this.next = false;
+			}
+		}
+	}
+
+	@Override
+	public boolean hasNext() {
+		return next;
+	}
+
+	@Override
+	public void init() {
+		
+		// Set first set value to the start value
+		if(positiveDirection){
+			this.count = 0; // Set count to the first element
+		}
+		else{
+			this.count = table.length-1; // Set count to the last element
+		}
+		
+		if(table.length>0){
+			this.next = true;
+		}
+	}
+
+	@Override
+	public void reverse() {
+		if(positiveDirection){
+			positiveDirection=false;
+		}
+		else{
+			positiveDirection=true;
+		}
+	}
+
+	@Override
+	public void reset() {
+		this.positiveDirection = this.originalPositiveDirection;
+	}
+
+	public boolean isAsynchronous() {
+		return asynchronous;
+	}
+	public void setAsynchronous(boolean asynchronous) {
+		this.asynchronous = asynchronous;
+	}
+}

src/main/java/ch/psi/fda/core/actors/ComplexActuator.java

@@ -0,0 +1,201 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Action;
+import ch.psi.fda.core.Actor;
+
+/**
+ * Complex actuator that consists of a list of other actuators. The steps of this actor are composed out of the
+ * steps of the actors that this actuator consists of.
+ * First all the steps of the first actor are used, after that the steps of the next actor are done.
+ * Before the first step of an actor pre actions are available and after the last step of an actor a post action is available.
+ */
+public class ComplexActuator implements Actor {
+
+	private static Logger logger = Logger.getLogger(ComplexActuator.class.getName());
+	
+	/**
+	 * List of actors this actor is made of
+	 */
+	private final List<Actor> actors;
+	
+	/**
+	 * Actions that are executed directly before the first step of this actor
+	 */
+	private final List<Action> preActions;
+	
+	/**
+	 * Actions that are executed directly after the last step of this actor
+	 */
+	private final List<Action> postActions;
+	
+	/**
+	 * Flag that indicates whether there is a next set value for the Actor
+	 */
+	private boolean next;
+	
+	/**
+	 * Index of the actor currently used
+	 */
+	private int actualActorCount;
+	
+	/**
+	 * Actor currently used to perform steps
+	 */
+	private Actor actualActor;
+	
+	/**
+	 * Flag to indicate the first set() execution of this actor.
+	 * This flag is used to decide whether to execute the pre actions.
+	 */
+	private boolean firstrun;
+	
+	public ComplexActuator(){
+		this.actors = new ArrayList<Actor>();
+		this.preActions = new ArrayList<Action>();
+		this.postActions = new ArrayList<Action>();
+		
+		this.next = false;
+		this.actualActorCount = 0;
+		
+		this.firstrun = true;
+	}
+	
+	@Override
+	public void set() throws InterruptedException {
+		if(!next){
+			throw new IllegalStateException("The actuator does not have any next step.");
+		}
+		
+		// PRE actions
+		if(firstrun){
+			this.firstrun = false;
+			
+			// Execute pre actions
+			logger.finest("Execute pre actions");
+			for(Action action: preActions){
+				action.execute();
+			}
+		}
+		
+		actualActor.set(); // If the actor has no next step then something is wrong in the init/next step logic
+		
+		// If the last point of the actual actuator is set take the next actuator in the list if there is one available
+		while(!actualActor.hasNext()&&actualActorCount<actors.size()){
+			actualActorCount++;
+			if(actualActorCount<actors.size()){
+				actualActor = actors.get(actualActorCount);
+			}
+			else{
+				break;
+			}
+		}
+		
+		if(actualActor.hasNext()){
+			this.next = true;
+		}
+		else{
+			this.next = false;
+			
+			// Execute post actions
+			logger.finest("Execute post actions");
+			for(Action action: postActions){
+				action.execute();
+			}
+		}
+		
+	}
+
+	@Override
+	public boolean hasNext() {
+		return next;
+	}
+
+	@Override
+	public void init() {
+		// Initialize all actors this actor consist of
+		for(Actor a: actors){
+			a.init();
+		}
+		
+		// Set the actual actor to the first actor in the list
+		actualActorCount=0;
+		if(actualActorCount<actors.size()){
+			actualActor = actors.get(actualActorCount);
+			
+			// Check whether the actor has a next step, if not increase to the next one
+			// This is needed because the first actor might not have any step ... (very unlikely but bad things happens some time)
+			while(!actualActor.hasNext()&&actualActorCount<actors.size()){
+				actualActorCount++;
+				if(actualActorCount<actors.size()){
+					actualActor = actors.get(actualActorCount);
+				}
+				else{
+					break;
+				}
+			}
+			
+			if(actualActor.hasNext()){
+				this.next = true;
+			}
+			else{
+				this.next = false;
+			}
+			
+		}
+		else{
+			actualActor=null;
+			this.next=false;
+		}
+		
+		this.firstrun = true;
+	}
+
+	@Override
+	public void reverse() {
+		// Reverse all actors this actor consist of
+		for(Actor a: actors){
+			a.reverse();
+		}
+	}
+	
+	@Override
+	public void reset() {
+		// Reset all actors this actor consist of
+		for(Actor a: actors){
+			a.reset();
+		}
+	}
+	
+	public List<Action> getPreActions() {
+		return preActions;
+	}
+	public List<Actor> getActors() {
+		return actors;
+	}
+	public List<Action> getPostActions() {
+		return postActions;
+	}
+}

src/main/java/ch/psi/fda/core/actors/Function.java

@@ -0,0 +1,24 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+public interface Function {
+	public double calculate(double parameter);
+}

src/main/java/ch/psi/fda/core/actors/JythonFunction.java

@@ -0,0 +1,106 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+import java.util.Map;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineManager;
+import javax.script.ScriptException;
+
+import ch.psi.fda.core.scripting.JythonGlobalVariable;
+
+public class JythonFunction implements Function {
+	
+	private static final Logger logger = Logger.getLogger(JythonFunction.class.getName());
+
+	public static final String ENTRY_FUNCTION_NAME = "calculate";
+	private static final String ENTRY_FUNCTION_PATTERN = "def "+ENTRY_FUNCTION_NAME+"\\((.*)\\):";
+	
+	private ScriptEngine engine;
+	private String additionalParameter = "";
+	
+	
+	public JythonFunction(String script, Map<String, JythonGlobalVariable> map){
+		
+		// Workaround for Jython memory leak 
+		// http://blog.hillbrecht.de/2009/07/11/jython-memory-leakout-of-memory-problem/
+		System.setProperty("python.options.internalTablesImpl","weak");
+		
+		this.engine = new ScriptEngineManager().getEngineByName("python");
+		
+		// Determine script entry function and the function parameters
+		String[] parameter;
+		Pattern pattern = Pattern.compile(ENTRY_FUNCTION_PATTERN);
+		Matcher matcher = pattern.matcher(script);
+		if(matcher.find() && matcher.groupCount()==1){
+			if(!matcher.group(1).trim().equals("")){
+				logger.finest("Entry function '"+ENTRY_FUNCTION_PATTERN+"' found - Identified parameters: "+matcher.group(1));
+				parameter = matcher.group(1).split(" *, *");
+			}
+			else{
+				parameter = new String[0];
+			}
+		}
+		else{
+			throw new IllegalArgumentException("Cannot determine entry function: "+ENTRY_FUNCTION_PATTERN);
+		}
+		
+		// Check whether all parameters are mapped
+		StringBuilder b = new StringBuilder();
+		for(int i=1;i<parameter.length; i++){ // Starting at 1 because first argument is implicit.
+			if(!map.containsKey(parameter[i])){
+				throw new IllegalArgumentException("Function parameter "+parameter[i]+" is not mapped");
+			}
+			b.append(",");
+			b.append(parameter[i]);
+		}
+		additionalParameter = b.toString();
+		
+		// Set variables in Jython engine
+		for(String k: map.keySet()){
+			engine.put(k, map.get(k));
+		}
+		
+		// Load manipulation script
+		try {
+			engine.eval(script);
+		} catch (ScriptException e) {
+			throw new RuntimeException("Unable to load manipulation script", e);
+		}
+	}
+	
+	@Override
+	public double calculate(double parameter) {
+		logger.fine("Function called");
+		
+		try {
+			logger.info("calculate( "+parameter+""+additionalParameter+" )");
+			return ((Double) engine.eval("calculate( "+parameter+""+additionalParameter+" )"));
+		} catch (ScriptException e) {
+			throw new RuntimeException("Calculating actuator step failed while executing the Jython script",e);
+		}
+		
+	}
+
+}

src/main/java/ch/psi/fda/core/actors/PseudoActuatorSensor.java

@@ -0,0 +1,93 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.actors;
+
+import ch.psi.fda.core.Actor;
+import ch.psi.fda.core.Sensor;
+
+/**
+ * Pseudo actor that is literally doing nothing for n times
+ */
+public class PseudoActuatorSensor implements Actor, Sensor {
+
+	/**
+	 * Execution count of actuator.
+	 */
+	private int count;
+	
+	/**
+	 * Number of counts for this actuator
+	 */
+	private final int counts;
+	
+	private final String id;
+	
+	/**
+	 * @param counts
+	 * @param id		Id of the Actor/Sensor
+	 */
+	public PseudoActuatorSensor(String id, int counts){
+		if(counts < 1){
+			throw new IllegalArgumentException("Count ["+counts+"] must be > 0");
+		}
+		this.id = id;
+		this.counts = counts;
+		
+		init();
+	}
+	
+	
+	@Override
+	public void set() {
+		if(!hasNext()){
+			throw new IllegalStateException("The actuator does not have any next step.");
+		}
+		
+		count++;
+	}
+
+	@Override
+	public boolean hasNext() {
+		return (count<counts);
+	}
+
+	@Override
+	public void init() {
+		count=0;
+	}
+
+	@Override
+	public void reverse() {
+	}
+
+	@Override
+	public void reset() {
+	}
+
+	@Override
+	public Object read() {
+		return new Double(count); // Return actual count
+	}
+
+	@Override
+	public String getId() {
+		return this.id;
+	}
+}

src/main/java/ch/psi/fda/core/guard/ChannelAccessGuard.java

@@ -0,0 +1,89 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.guard;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import ch.psi.fda.core.Guard;
+import ch.psi.jcae.ChannelException;
+
+/**
+ * Guard checking channels to meet a certain condition
+ */
+public class ChannelAccessGuard implements Guard {
+	
+	private static Logger logger = Logger.getLogger(ChannelAccessGuard.class.getName());
+	
+	/**
+	 * Flag to indicate whether a guard condition failed since the last init call
+	 * true: all conditions met, false: at least one condition failed
+	 */
+	private volatile boolean check = true;
+	
+	private final List<ChannelAccessGuardCondition<?>> conditions;
+	
+	public ChannelAccessGuard(List<ChannelAccessGuardCondition<?>> conditions){
+
+		this.conditions = conditions;
+		
+		for(final ChannelAccessGuardCondition<?> condition: conditions){
+			condition.getChannel().addPropertyChangeListener(new PropertyChangeListener() {		
+				@Override
+				public void propertyChange(PropertyChangeEvent evt) {
+					if(! evt.getNewValue().equals(condition.getValue())){
+						check=false;
+					}
+				}
+			});
+		}
+	}
+	
+	@Override
+	public void init() {
+		check = true;
+		
+		// Check one time if all conditions are met
+		for(ChannelAccessGuardCondition<?> condition: conditions){
+			try{
+				if(! (condition.getChannel().getValue(true)).equals(condition.getValue()) ){
+					check=false;
+					break;
+				}
+			}
+			catch (InterruptedException e) {
+				throw new RuntimeException("Guard interrupted ",e);
+			} catch (TimeoutException | ChannelException | ExecutionException e) {
+				logger.log(Level.WARNING, "Unable ", e);
+				check=false;
+			}
+		}
+	}
+
+	@Override
+	public boolean check() {
+		return check;
+	}
+}

src/main/java/ch/psi/fda/core/guard/ChannelAccessGuardCondition.java

@@ -0,0 +1,41 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.guard;
+
+import ch.psi.jcae.Channel;
+
+public class ChannelAccessGuardCondition<T> {
+	
+	private final Channel<T> channel;
+	private final T value; // Value of the channel to meet condition
+
+	public ChannelAccessGuardCondition(Channel<T> channel, T value){
+		this.channel = channel;
+		this.value = value;
+	}
+	
+	public Channel<T> getChannel() {
+		return channel;
+	}
+
+	public T getValue() {
+		return value;
+	}
+}

src/main/java/ch/psi/fda/core/loops/ActorSensorLoop.java

@@ -0,0 +1,436 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.logging.Logger;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.core.Action;
+import ch.psi.fda.core.ActionLoop;
+import ch.psi.fda.core.Actor;
+import ch.psi.fda.core.ActorSetCallable;
+import ch.psi.fda.core.Guard;
+import ch.psi.fda.core.Sensor;
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.messages.Metadata;
+
+/**
+ * Loop of actions to accomplish a task or test.
+ */
+public class ActorSensorLoop implements ActionLoop {
+	
+	private static Logger logger = Logger.getLogger(ActorSensorLoop.class.getName());
+	
+	/**
+	 * Flag to indicate whether the data of this loop will be grouped
+	 * According to this flag the dataGroup flag in EndOfStream will be set.
+	 */
+	private boolean dataGroup = false;
+	
+	/**
+	 * List of additional action loops that are executed at the end of each
+	 * iteration of the loop
+	 */
+	private List<ActionLoop> actionLoops;
+	/**
+	 * List of actions that are executed at the beginning of the loop.
+	 */
+	private List<Action> preActions;
+	/**
+	 * List of actions that are executed at the end of the loop.
+	 */
+	private List<Action> postActions;
+	
+	/**
+	 * List of actions that are executed before the actors are set
+	 */
+	private List<Action> preActorActions;
+	
+	/**
+	 * List of actions that are executed after all actors have been set
+	 */
+	private List<Action> postActorActions;
+	
+	/**
+	 * List of actions that are executed before the sensors are read out
+	 */
+	private List<Action> preSensorActions;
+	/**
+	 * List of actions that are executed after all sensors have been read out
+	 */
+	private List<Action> postSensorActions;
+	
+	/**
+	 * List of actors of this loop
+	 */
+	private List<Actor> actors;
+	
+	/**
+	 * List of sensors of this loop
+	 */
+	private List<Sensor> sensors;
+	
+	/**
+	 * Guard used to check whether the environment was ok while reading out the sensors
+	 */
+	private Guard guard = null;
+	
+	private volatile boolean loop = false;
+	private volatile boolean abort = false;
+	
+	private final boolean zigZag;
+	
+	private List<ActorSetCallable> pactors;
+	
+	private EventBus eventBus = new EventBus();
+	
+	
+	public ActorSensorLoop(){
+		this(false);
+	}
+	
+	public ActorSensorLoop(boolean zigZag){
+		this.zigZag = zigZag;
+		this.actionLoops = new ArrayList<ActionLoop>();
+		this.preActions = new ArrayList<Action>();
+		this.postActions = new ArrayList<Action>();
+		this.preActorActions = new ArrayList<Action>();
+		this.postActorActions = new ArrayList<Action>();
+		this.preSensorActions = new ArrayList<Action>();
+		this.postSensorActions = new ArrayList<Action>();
+		
+		this.actors = new ArrayList<Actor>();
+		this.pactors = new ArrayList<ActorSetCallable>();
+		this.sensors = new ArrayList<Sensor>();
+	}
+	
+	
+	/**
+	 * Executes the actor sensor loop. The actor sensor loop is build up as follows:
+	 * preActions
+	 * loop{
+	 *  check actors - abort if there are no new steps
+	 *  pre actor actions
+	 *  set actors
+	 *  post actor actions
+	 *  pre sensor actions
+	 *  read sensors
+	 *  post sensor actions
+	 *  execute additional registered action loops
+	 * }
+	 * postActions
+	 * @throws InterruptedException 
+	 */
+	@Override
+	public void execute() throws InterruptedException {
+		abort = false;
+		
+		List<Metadata> metadata = new ArrayList<>();
+		
+		// Build up data message metadata based on the sensors currently registered.
+		for(Sensor s: sensors){
+			metadata.add(new Metadata(s.getId()));
+		}
+		
+		
+		/**
+		 * Thread pool for parallel execution of tasks
+		 */
+		ExecutorService executorService = Executors.newCachedThreadPool();
+		
+		loop = true;
+		
+		// Execute pre actions
+		for(Action action: preActions){
+			action.execute();
+		}
+		
+		// Initialize actors of Loop
+		for(Actor actor: actors){
+			actor.init();
+		}
+		
+		// Variable to store the last guard status
+		boolean guardOK=true;
+		
+		try{
+			
+			// Execute loop logic
+			while(loop){
+				
+				if(guardOK){
+					
+					
+					// If actors are defined for the loop check whether all of them
+					// have a next step defined if there is no actor defined only run this loop once
+					if(actors.size()>0){
+						// Check whether the actors of this loop have a next step. If not 
+						// abort the loop
+						boolean hasNext = true;
+						for(Actor actor: actors){
+							if(!actor.hasNext()){
+								hasNext=false;
+								break; // Stop actor check loop
+							}
+						}
+						
+						// If not all actors have a next step abort the loop
+						if(!hasNext){
+							break; // Stop action loop
+						}
+					}
+					else{
+						// No actors defined, only run loop once
+						loop = false;
+					}
+		
+					
+					
+					// Execute pre actor actions
+					for(Action action: preActorActions){
+						action.execute();
+					}
+					
+					if(abort){ // End loop if abort was issued
+						break;
+					}
+					
+					// Set actors
+	//				for(Actor actor: actors){
+	//					actor.set();
+	//				}
+					// Parallel set of the actors
+					try {
+						for (Future<Object> f : executorService.invokeAll(pactors)) {
+						    f.get(); //Blocks until the async set() is finished
+						}
+					} catch (ExecutionException e) {
+						throw new RuntimeException("Setting the actors failed",e);
+					}
+					
+					// Execute post actor actions
+					for(Action action: postActorActions){
+						action.execute();
+					}
+					
+					if(abort){ // End loop if abort was issued
+						break;
+					}
+				
+				}
+				
+				if(guard!=null){
+					// Initialize guard
+					guard.init();
+					guardOK=guard.check();
+					
+					// Wait until guard is ok
+					while(!guardOK){
+						logger.info("Waiting for guard condition(s) to be met");
+						// Sleep 100 milliseconds before next check
+						Thread.sleep(1000);
+						
+						// Check whether the loop is not aborted, if it is aborted
+						// break the wait loop (afterwards also the loop loop is aborted)
+						if(!loop){
+							break;
+						}
+						
+						guard.init();
+						guardOK=guard.check();
+					}
+					
+					// If loop is aborted proceed to next iteration an abort loop
+					if(!loop){
+						continue;
+					}
+				}
+				
+				// Execute pre sensor actions
+				for(Action action: preSensorActions){
+					action.execute();
+				}
+				
+				if(abort){ // End loop if abort was issued
+					break;
+				}
+				
+				// Read sensors
+				DataMessage message = new DataMessage(metadata);
+				for(Sensor sensor: sensors){
+					// Readout sensor
+					Object o = sensor.read();
+					// Add sensor data item to message
+					message.getData().add(o);
+				}
+				
+				// Execute post sensor actions
+				for(Action action: postSensorActions){
+					action.execute();
+				}
+				
+				if(abort){ // End loop if abort was issued
+					break;
+				}
+				
+				// Check guard if one is registered
+				if(guard!=null){
+					guardOK=guard.check();
+				}
+				
+				if(guardOK){
+				
+					// Post a message with the sensor data
+					eventBus.post(message);
+					
+					// Loop all configured ActionLoop objects
+					for(ActionLoop actionLoop: actionLoops){
+						actionLoop.execute();
+					}
+				}
+			}
+			
+			// Execute post actions
+			for(Action action: postActions){
+				action.execute();
+			}
+		
+		}
+		finally{
+			// Ensure that data stream is terminated ...
+			
+			// Issue end of loop control message
+			// Set iflag of the EndOfStreamMessage according to dataGroup flag of this loop
+			eventBus.post(new EndOfStreamMessage(dataGroup));
+		}
+		
+		if(zigZag){
+			// Reverse actors for the next run
+			for(Actor actor: actors){
+				actor.reverse();
+			}
+		}
+		
+		executorService.shutdownNow();
+		
+	}
+
+	@Override
+	public void abort(){
+		abort = true;
+		loop = false;
+		
+		// To abort all wait actions interrupt this thread
+		for(Action a: preSensorActions){
+			a.abort();
+		}
+		
+		// Recursively abort all registered action loops
+		for(ActionLoop actionLoop: actionLoops){
+			actionLoop.abort();
+		}
+	}
+
+	@Override
+	public void prepare() {
+		// Create callable for all actors
+		pactors.clear();
+		for(final Actor a: actors){
+			pactors.add(new ActorSetCallable(a));
+		}
+		
+		// Reset all actuators
+		for(Actor a: actors){
+			a.reset();
+		}
+		
+		// Recursively call prepare() method of all registered action loops
+		for(ActionLoop actionLoop: actionLoops){
+			actionLoop.prepare();
+		}
+	}
+
+	@Override
+	public void cleanup() {
+		// Recursively call cleanup() method of all registered action loops
+		for(ActionLoop actionLoop: actionLoops){
+			actionLoop.cleanup();
+		}
+	}
+	
+	@Override
+	public List<Action> getPreActions() {
+		return preActions;
+	}
+
+	@Override
+	public List<Action> getPostActions() {
+		return postActions;
+	}
+	
+
+	@Override
+	public EventBus getEventBus(){
+		return eventBus;
+	}
+	
+	
+	public List<ActionLoop> getActionLoops() {
+		return actionLoops;
+	}
+	public List<Action> getPreActorActions() {
+		return preActorActions;
+	}
+	public List<Action> getPostActorActions() {
+		return postActorActions;
+	}
+	public List<Action> getPreSensorActions() {
+		return preSensorActions;
+	}
+	public List<Action> getPostSensorActions() {
+		return postSensorActions;
+	}
+	public List<Actor> getActors() {
+		return actors;
+	}
+	public List<Sensor> getSensors() {
+		return sensors;
+	}
+	public Guard getGuard() {
+		return guard;
+	}
+	public void setGuard(Guard guard) {
+		this.guard = guard;
+	}
+	public boolean isDataGroup() {
+		return dataGroup;
+	}
+	public void setDataGroup(boolean dataGroup) {
+		this.dataGroup = dataGroup;
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/CrlogicDeltaDataFilter.java

@@ -0,0 +1,46 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops.cr;
+
+/**
+ * Filter calculating the delta of two subsequent values
+ */
+public class CrlogicDeltaDataFilter {
+
+	private Double lastValue = null;
+	
+	public void reset(){
+		lastValue = null;
+	}
+	
+	public Double delta(Double value){
+		
+		Double lvalue = lastValue;
+		lastValue = value;
+		
+		if(lvalue==null){
+			return Double.NaN;
+		}
+		else{
+			// Return delta
+			return(value-lvalue);
+		}
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/CrlogicLoopStream.java

@@ -0,0 +1,723 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops.cr;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import org.zeromq.ZMQ;
+import org.zeromq.ZMQ.Context;
+import org.zeromq.ZMQ.Socket;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.core.Action;
+import ch.psi.fda.core.ActionLoop;
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.messages.Metadata;
+import ch.psi.jcae.ChannelException;
+import ch.psi.jcae.ChannelService;
+
+/**
+ * While using Crlogic the IOC system clock rate should/must be set to 1000 (default 60)
+ * 
+ * sysClkRateSet 1000
+ *
+ */
+public class CrlogicLoopStream implements ActionLoop {
+	
+	private static final Logger logger = Logger.getLogger(CrlogicLoopStream.class.getName());
+	
+	public static final int HIGH_WATER_MARK = 100;
+	private Context context;
+	private Socket socket;
+	
+	private ObjectMapper mapper = new ObjectMapper();
+	
+	/**
+	 * Flag to indicate whether the data of this loop will be grouped
+	 * According to this flag the dataGroup flag in EndOfStream will be set.
+	 */
+	private boolean dataGroup = false;
+	
+	// Default timeout (in milliseconds) for wait operations
+	private long startStopTimeout = 8000;
+	
+	
+	private String ioc;
+	
+	/**
+	 * Flag whether the actor of this loop should move in zig zag mode
+	 */
+	private final boolean zigZag;
+	
+	private boolean useReadback;
+	private boolean useEncoder;
+	
+
+	private List<Action> preActions;
+	private List<Action> postActions;
+	private List<CrlogicResource> sensors;
+	
+	// Prefix for the CRLOGIC channels
+	private final String prefix;
+	
+	private TemplateCrlogic template;
+	private TemplateMotor motortemplate;
+	
+	private List<String> readoutResources;
+	private Map<Integer, CrlogicDeltaDataFilter> scalerIndices;
+	private CrlogicRangeDataFilter crlogicDataFilter;
+	
+	private boolean abort = false;
+	
+	private final ChannelService cservice;
+	
+	private String id;
+	private String name; // name of the motor channel
+	private String readback; // name of the encoder channel
+	private double start;
+	private double end;
+	private double stepSize;
+	private double integrationTime;
+	private double additionalBacklash;
+	
+	
+	private final EventBus eventbus;
+	private List<Metadata> metadata;
+	
+	
+	/**
+	 * Constructor
+	 * @param cservice	Channel Access context
+	 * @param prefix	Prefix of the IOC channels
+	 * @param ioc		Name of the IOC running CRLOGIC
+	 * @param zigZag	Do zigZag scan
+	 */
+	public CrlogicLoopStream(ChannelService cservice, String prefix, String ioc, boolean zigZag){
+		eventbus = new EventBus();
+		this.cservice = cservice;
+		this.prefix = prefix;
+		this.ioc = ioc;
+		this.zigZag = zigZag;
+		
+		// Initialize lists used by the loop
+		this.preActions = new ArrayList<Action>();
+		this.postActions = new ArrayList<Action>();
+		this.sensors = new ArrayList<>();
+		this.readoutResources = new ArrayList<String>();
+		this.scalerIndices = new HashMap<Integer, CrlogicDeltaDataFilter>();
+		
+		this.crlogicDataFilter = new CrlogicRangeDataFilter();
+	}
+
+	
+	public void setActuator(String id, String name, String readback, double start, double end, double stepSize, double integrationTime, double additionalBacklash){
+		this.id = id;
+		this.name = name;
+		this.readback = readback;
+		this.start = start;
+		this.end = end;
+		this.stepSize = stepSize;
+		this.integrationTime = integrationTime;
+		this.additionalBacklash = additionalBacklash;
+	}
+	
+
+	/**
+	 * Receive a ZMQ message
+	 */
+	private  void receive() {
+		
+		MainHeader mainHeader;
+		
+		try {
+			byte[] bytes = socket.recv(ZMQ.NOBLOCK);
+			if(bytes == null){
+				// There is no message hanging
+				return;
+			}
+			mainHeader = mapper.readValue(bytes, MainHeader.class);
+		} catch (IOException e) {
+			throw new RuntimeException("Unable to decode main header", e);
+		}
+		
+		if(!socket.hasReceiveMore()){
+			throw new RuntimeException("There is no data submessage");
+		}
+		
+		byte[] bytes = socket.recv();
+		ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
+		
+		DataMessage message = new DataMessage(metadata);
+		boolean use = true;
+		
+		for(int i=0; i<mainHeader.getElements(); i++){
+			Double raw = byteBuffer.getDouble();
+			Double val;
+			
+			if(i==0){
+				if(useEncoder){
+					val = crlogicDataFilter.calculatePositionMotorUseEncoder(raw);
+				}
+				else if(useReadback){
+					val = crlogicDataFilter.calculatePositionMotorUseReadback(raw);
+				}
+				else{
+					val = crlogicDataFilter.calculatePositionMotor(raw);
+				}
+				
+				// Check whether data is within the configured range - otherwise drop data
+				use = crlogicDataFilter.filter(val);
+			}
+			else if(scalerIndices.containsKey(i)){
+				CrlogicDeltaDataFilter f = scalerIndices.get(i); 
+				val = f.delta(raw);
+			}
+			else{
+				val = raw;
+			}
+			
+			message.getData().add(val);
+		}
+		
+		// Drain remaining messages
+		int n = drainHangingSubmessages();
+		if(n>1){
+			throw new RuntimeException("More than 1 message drained from stream: "+n);
+		}
+		
+		if(use){
+			eventbus.post(message);
+		}		
+	}
+	
+	
+	
+	@Override
+	public void execute() throws InterruptedException {
+		try{
+		
+			// Set values for the datafilter
+			crlogicDataFilter.setStart(start);
+			crlogicDataFilter.setEnd(end);
+			
+			// Reset data filter
+			for(Integer k: scalerIndices.keySet()){
+				scalerIndices.get(k).reset();
+			}
+			
+			// Set abort state to false
+			abort = false;
+			
+			Long timeout = 600000l; // 10 minutes move timeout
+			
+			// Check if logic is inactive, otherwise return early
+			if(!template.getStatus().getValue().equals(TemplateCrlogic.Status.INACTIVE.toString())){
+				logger.info("CRLOGIC is not inactive!");
+				// TODO Decide what to do in this situation
+				
+				if(template.getStatus().getValue().equals(TemplateCrlogic.Status.FAULT.toString())){
+					// If in fault show message and recover
+					logger.info("CRLOGIC in FAULT state");
+					logger.info("Error message: "+template.getMessage().getValue());
+					logger.info("Recover logic and set it to INACTIVE");
+					template.getStatus().setValue(TemplateCrlogic.Status.INACTIVE.toString());
+				}
+				else if(template.getStatus().getValue().equals(TemplateCrlogic.Status.ACTIVE.toString())){
+					template.getStatus().setValue(TemplateCrlogic.Status.STOP.toString());
+					template.getStatus().waitForValue(TemplateCrlogic.Status.INACTIVE.toString(), startStopTimeout);
+				}
+				else{
+					throw new RuntimeException("CRLOGIC is not inactive");
+				}
+			}
+			
+			logger.info("Set parameters");
+			template.getNfsServer().setValue("");
+			template.getNfsShare().setValue("");
+			template.getDataFile().setValue("");
+			
+			int tps = template.getTicksPerSecond().getValue();
+			logger.info("Ticks per second: "+tps);
+			
+			logger.info("Set readout resources");
+			
+			template.getReadoutResources().setValue(readoutResources.toArray(new String[readoutResources.size()]));
+			
+			
+			
+			// Set ticks between interrupt to integration time
+			int ticks = (int)(tps*integrationTime);
+			template.getTicksBetweenInterrupts().setValue(ticks);
+			
+			// Prepare motor
+			double totalTimeSeconds = Math.abs((end-start)/stepSize*integrationTime);
+			int hours = (int) Math.floor(totalTimeSeconds/60/60);
+			int minutes = (int) Math.floor(totalTimeSeconds/60-hours*60);
+			int seconds = (int) Math.floor(totalTimeSeconds-hours*60*60-minutes*60);
+			
+			logger.info("Estimated time: "+hours+":"+minutes+":"+seconds);
+			
+			int direction = 1;
+			if(end-start<0){
+				direction = -1;
+			}
+			
+			double motorBaseSpeed = motortemplate.getBaseSpeed().getValue();
+			double motorHighLimit = motortemplate.getHighLimit().getValue();
+			double motorLowLimit = motortemplate.getLowLimit().getValue();
+			double motorBacklash = motortemplate.getBacklashDistance().getValue();
+			
+			boolean respectMotorMinSpeed = false; // if false set min speed to 0
+			double motorMinSpeed = 0;
+			if(respectMotorMinSpeed){
+				motorMinSpeed = motorBaseSpeed;
+			}
+			
+			// Check user parameters
+			// TODO start and end values must be between the motor high and low value - otherwise fail
+			if(start>motorHighLimit || start<motorLowLimit){
+				// Start value is outside motor high and/or low value
+				logger.info("Start value is outside motor high and/or low value");
+				throw new IllegalArgumentException("Start value is outside motor high and/or low value");
+			}
+			if(end>motorHighLimit || end<motorLowLimit){
+				// End value is outside motor high and/or low value
+				logger.info("End value is outside motor high and/or low value");
+				throw new IllegalArgumentException("End value is outside motor high and/or low value");
+			}
+			// TODO Check minimum step size
+			int minimumTicks = 10;
+			double minStepSize = motorMinSpeed*(minimumTicks/tps);
+			if(stepSize<minStepSize){
+				// Step size is too small
+				logger.info("Step size is too small");
+				throw new IllegalArgumentException("Step size is too small");
+			}
+			// TODO Check integration time
+			if(motorMinSpeed>0){
+				double maxIntegrationTime = stepSize/motorMinSpeed;
+				if(integrationTime>maxIntegrationTime){
+					logger.info("Integration time is too big");
+					// Integration time is too big
+					throw new IllegalArgumentException("Integration time is too big");
+				}
+			}
+			double motorMaxSpeed = motortemplate.getVelocity().getValue();
+			double minIntegrationTime = Math.min( (stepSize/motorMaxSpeed), ((double)minimumTicks/(double)tps) );
+			if(integrationTime<minIntegrationTime){
+				// Integration time is too small
+				logger.info("Integration time is too small [min integration time: "+minIntegrationTime+"]");
+				throw new IllegalArgumentException("Integration time is too small [min integration time: "+minIntegrationTime+"]");
+			}
+			
+			
+			// TODO Calculate and set motor speed, backlash, etc.
+			double motorSpeed = stepSize/integrationTime;
+			double backlash = (0.5*motorSpeed*motortemplate.getAccelerationTime().getValue())+motorBacklash+additionalBacklash;
+			double realEnd = end+(backlash*direction);
+			double realStart = start-(backlash*direction);
+	
+			
+			// Move to start
+			logger.info("Move motor to start ["+realStart+"]");
+			motortemplate.getSetValue().setValueAsync(realStart).get(timeout, TimeUnit.MILLISECONDS); // Will block until move is done
+			
+			
+			// Set motor paramters
+			// Backup settings
+			logger.info("Backup motor settings");
+			double backupSpeed = motortemplate.getVelocity().getValue();
+			double backupBacklash = motorBacklash;
+			double backupMinSpeed = motorBaseSpeed;
+			
+			try{
+				// Set motor settings
+				logger.info("Update motor settings");
+//				if(!respectMotorMinSpeed){
+//					motortemplate.getBaseSpeed().setValue(0d);
+//				}
+				// Set base speed as fast as possible but not faster than the original base speed.
+				double base = motorBaseSpeed;
+				if(motorSpeed<base){
+					base = motorSpeed;
+				}
+				motortemplate.getBaseSpeed().setValue(base);
+				motortemplate.getVelocity().setValue(motorSpeed);
+				motortemplate.getBacklashDistance().setValue(0d);
+				
+				
+				// Execute pre actions
+				for(Action action: preActions){
+					action.execute();
+				}
+				
+				
+				// Start crlogic logic
+				logger.info("Start CRLOGIC");
+				template.getStatus().setValue(TemplateCrlogic.Status.INITIALIZE.toString());
+				try{
+					template.getStatus().waitForValue(TemplateCrlogic.Status.ACTIVE.toString(), startStopTimeout);
+				}
+				catch(ChannelException | ExecutionException | TimeoutException e){
+					logger.info( "Failed to start CRLOGIC. Logic in status: "+template.getStatus().getValue() );
+					if(template.getStatus().getValue().equals(TemplateCrlogic.Status.FAULT.toString())){
+						logger.info("Error message: "+template.getMessage().getValue());
+					}
+					// Recover to inactive
+					template.getStatus().setValue(TemplateCrlogic.Status.INACTIVE.toString());
+					// TODO Improve error handling
+					throw new RuntimeException("Failed to start CRLOGIC. Logic in status: "+template.getStatus().getValue()+ " Error message: "+template.getMessage().getValue(), e);
+					
+				}
+
+				// Connect ZMQ stream
+				connect(ioc);
+//				drainHangingSubmessages();
+				
+				// Move motor(s) to end / wait until motor is stopped
+				logger.info("Move motor to end ["+realEnd+"]");
+				try{
+					
+					// This is the continuous motor move
+					Future<Double> future = motortemplate.getSetValue().setValueAsync(realEnd);
+					
+					long timeoutTime = System.currentTimeMillis()+timeout;
+					
+					// This loop will keep spinning until the motor reached the final position
+					while(!future.isDone()){
+						if(System.currentTimeMillis()>timeoutTime){
+							throw new TimeoutException("Motion timed out");
+						}
+						
+						receive(); // TODO Problem still blocking
+
+						if(abort){
+							// Abort motor move 
+							motortemplate.getCommand().setValue(TemplateMotor.Commands.Stop.ordinal());
+							motortemplate.getCommand().setValue(TemplateMotor.Commands.Go.ordinal());
+							break;
+						}
+						
+					}
+				}
+				finally {
+					receive();
+					
+					// Send end of stream message
+					logger.info("Sending - End of Line - Data Group: "+ dataGroup);
+					eventbus.post(new EndOfStreamMessage(dataGroup));
+					
+					// Close ZMQ stream
+					close();
+				}
+				logger.info("Motor reached end position");
+				
+				// Stop crlogic logic
+				logger.info("Stop CRLOGIC");
+				template.getStatus().setValue(TemplateCrlogic.Status.STOP.toString());
+				// Wait until stopped
+				logger.info("Wait until stopped");
+				try{
+					template.getStatus().waitForValue(TemplateCrlogic.Status.INACTIVE.toString(), startStopTimeout);
+				}
+				catch(ChannelException | ExecutionException | TimeoutException e){
+					logger.info( "Failed to stop CRLOGIC. Logic in status: "+template.getStatus().getValue() );
+					// TODO Improve error handling
+					throw new RuntimeException("Failed to stop CRLOGIC.  Logic in status: "+template.getStatus().getValue(), e);
+				}
+				logger.info("CRLOGIC is now stopped");
+				
+				
+				// Execute post actions
+				for(Action action: postActions){
+					action.execute();
+				}
+				
+				
+			}
+			finally{
+				logger.info("Restore motor settings");
+				motortemplate.getBaseSpeed().setValue(backupMinSpeed);
+				motortemplate.getVelocity().setValue(backupSpeed);
+				motortemplate.getBacklashDistance().setValue(backupBacklash);
+			}
+
+			
+			if(zigZag){
+				// reverse start/end
+				double aend = end;
+				end=start;
+				start=aend;
+			}
+			
+		}
+		catch(ChannelException | ExecutionException | TimeoutException e){
+			throw new RuntimeException("Unable to execute crloop", e);
+		}
+	}
+
+	/**
+	 * Abort execution
+	 */
+	@Override
+	public void abort() {
+		abort = true;
+	}
+	
+	
+	/**
+	 * Prepare this loop for execution
+	 */
+	@Override
+	public void prepare() {
+		
+		metadata = new ArrayList<>();
+		
+		// Build up metadata
+		metadata.add(new Metadata(this.id));
+		for(CrlogicResource s: sensors){
+			metadata.add(new Metadata(s.getId()));
+		}
+		
+		try{
+			// Connect crlogic channels
+			template = new TemplateCrlogic();
+			logger.info("Connect channels");
+			Map<String,String> map = new HashMap<>();
+			map.put("PREFIX", prefix);
+			cservice.createAnnotatedChannels(template, map);
+			
+			// Connect motor channels
+			motortemplate = new TemplateMotor();
+			map = new HashMap<>();
+			map.put("PREFIX", this.name);
+			cservice.createAnnotatedChannels(motortemplate, map);
+			
+			useReadback = motortemplate.getUseReadback().getValue();
+			useEncoder = motortemplate.getUseEncoder().getValue();
+			
+			logger.info("Motor type: "+ TemplateMotor.Type.values()[motortemplate.getType().getValue()]);
+			logger.info("Motor use readback: "+useReadback);
+			logger.info("Motor use encoder: "+useEncoder);
+			
+			// TODO build up list of readout resources (based on sensors)
+			readoutResources.clear();
+			// first sensor is the actuator
+			
+			// Determine mode of motor
+			if((!useReadback) && (!useEncoder)){
+				// Open loop
+				if(this.readback!=null){
+					throw new IllegalArgumentException("Readback not supported if motor is configured in open loop");
+				}
+				else{
+					readoutResources.add(this.name);
+				}
+				
+			}
+			else if(useReadback && (!useEncoder)){
+				String readback;
+				// use readback link
+				if(this.readback!=null){
+					// Use specified readback
+					readback = this.readback;
+				}
+				else{
+					// Set resouce to readback link
+					readback = (motortemplate.getReadbackLink().getValue());
+					readback = readback.replaceAll(" +.*", ""); // remove NPP etc at the end
+				}
+				
+				readoutResources.add(readback);
+				
+				// Fill readback encoder settings
+				// Connect to encoder
+				TemplateEncoder encodertemplate = new TemplateEncoder();
+				map = new HashMap<>();
+				map.put("PREFIX", readback);
+				cservice.createAnnotatedChannels(encodertemplate, map);
+				
+				// Read encoder settings
+				if(encodertemplate.getDirection().getValue()==TemplateEncoder.Direction.Positive.ordinal()){
+					crlogicDataFilter.setEncoderDirection(1);
+				}
+				else{
+					crlogicDataFilter.setEncoderDirection(-1);
+				}
+				crlogicDataFilter.setEncoderOffset(encodertemplate.getOffset().getValue());
+				crlogicDataFilter.setEncoderResolution(encodertemplate.getResolution().getValue());
+				
+				// Disconnect from encoder
+				cservice.destroyAnnotatedChannels(encodertemplate);
+				
+			}
+			else if (useEncoder && (!useReadback)){
+				// use readback link
+				if(this.readback!=null){
+					throw new IllegalArgumentException("Readback not supported if motor is configured to use encoder");
+				}
+				else{
+					// Set resouce to readback link
+					readoutResources.add(this.name+"_ENC");
+				}
+			}
+			else{
+				throw new IllegalArgumentException("Motor configuration not supportet: use readback - "+useReadback+" use encoder - "+useEncoder);
+			}
+			
+			// Fill Motor specific settings
+			if(motortemplate.getDirection().getValue()==TemplateMotor.Direction.Positive.ordinal()){
+				crlogicDataFilter.setMotorDirection(1);
+			}
+			else{
+				crlogicDataFilter.setMotorDirection(-1);
+			}
+			crlogicDataFilter.setMotorEncoderResolution(motortemplate.getEncoderResolution().getValue());
+			crlogicDataFilter.setMotorOffset(motortemplate.getOffset().getValue());
+			crlogicDataFilter.setMotorReadbackResolution(motortemplate.getReadbackResolution().getValue());
+			crlogicDataFilter.setMotorResolution(motortemplate.getMotorResolution().getValue());
+			
+			// Clear all indices
+			scalerIndices.clear();
+			
+			int c = 1; // We start at 1 because the actuator right now is an implicit sensor 
+			for(CrlogicResource s: sensors){
+					readoutResources.add(s.getKey());
+					if(s.isDelta()){
+						scalerIndices.put(c, new CrlogicDeltaDataFilter());
+					}
+					c++;
+			}
+			
+			// Workaround - somehow one has to add an empty thing to the value otherwise the c logic 
+			// does not pick up the end
+			readoutResources.add("");
+		}
+		catch(Exception e){
+			throw new RuntimeException("Unable to prepare crloop: ",e);
+		}
+	}
+
+	
+	/**
+	 * Connect ZMQ stream
+	 * @param address	ZMQ endpoint address
+	 */
+	private void connect(String address) {
+		// Clear interrupted state
+		Thread.interrupted();
+		
+		logger.info("Connecting with IOC"+address);
+		context = ZMQ.context(1);
+		socket = context.socket(ZMQ.PULL);
+		socket.setRcvHWM(HIGH_WATER_MARK);
+		socket.connect("tcp://"+address+":9999");
+	}
+
+	
+	/**
+	 * Close ZMQ stream
+	 */
+	private void close() {
+		logger.info("Closing stream from IOC "+ioc);
+		
+		socket.close();
+		context.close();
+		socket = null;
+		context = null;
+	}
+	
+	
+	/**
+	 * Drain sub-messages
+	 * @return	Number of sub-messages drained
+	 */
+	private int drainHangingSubmessages() {
+		int count = 0;
+		while (socket.hasReceiveMore()) {
+			// is there a way to avoid copying data to user space here?
+			socket.recv();
+			count++;
+		}
+		if(count>0){
+			logger.info("Drain hanging submessages");
+		}
+		return count;
+	}
+	
+	
+	/**
+	 * Cleanup loop
+	 */
+	@Override
+	public void cleanup() {
+		logger.info("Cleanup");
+		try {
+			cservice.destroyAnnotatedChannels(template);
+			cservice.destroyAnnotatedChannels(motortemplate);
+			template = null;
+			motortemplate = null;
+		} catch (Exception e) {
+			throw new RuntimeException("Unable to destroy Channel Access channels", e);
+		}
+	}
+
+	
+	@Override
+	public List<Action> getPreActions() {
+		return preActions;
+	}
+
+	@Override
+	public List<Action> getPostActions() {
+		return postActions;
+	}
+	
+	public List<CrlogicResource> getSensors() {
+		return sensors;
+	}
+
+	@Override
+	public boolean isDataGroup() {
+		return dataGroup;
+	}
+
+	@Override
+	public void setDataGroup(boolean dataGroup) {
+		this.dataGroup = dataGroup;
+	}
+	
+	public EventBus getEventBus(){
+		return eventbus;
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/CrlogicRangeDataFilter.java

@@ -0,0 +1,270 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops.cr;
+
+public class CrlogicRangeDataFilter {
+
+	private double motorResolution = 1;
+	private int motorDirection = 1;
+	private double motorOffset = 0;
+	private double motorReadbackResolution = 1;
+	private double motorEncoderResolution = 1;
+	
+	private double encoderOffset = 0;
+	private double encoderResolution = 1;
+	private int encoderDirection = 1;
+	
+	private double start = 0;
+	private double end = 0;
+	private boolean positive = true;
+	
+	/**
+	 * Marker whether the value was equal
+	 */
+	private boolean wasEqualBefore = false;
+	
+	/**
+	 * @return the motorResolution
+	 */
+	public double getMotorResolution() {
+		return motorResolution;
+	}
+
+	/**
+	 * @param motorResolution the motorResolution to set
+	 */
+	public void setMotorResolution(double motorResolution) {
+		this.motorResolution = motorResolution;
+	}
+
+	/**
+	 * @return the motorDirection
+	 */
+	public int getMotorDirection() {
+		return motorDirection;
+	}
+
+	/**
+	 * @param motorDirection the motorDirection to set
+	 */
+	public void setMotorDirection(int motorDirection) {
+		this.motorDirection = motorDirection;
+	}
+
+	/**
+	 * @return the motorOffset
+	 */
+	public double getMotorOffset() {
+		return motorOffset;
+	}
+
+	/**
+	 * @param motorOffset the motorOffset to set
+	 */
+	public void setMotorOffset(double motorOffset) {
+		this.motorOffset = motorOffset;
+	}
+
+	/**
+	 * @return the motorReadbackResolution
+	 */
+	public double getMotorReadbackResolution() {
+		return motorReadbackResolution;
+	}
+
+	/**
+	 * @param motorReadbackResolution the motorReadbackResolution to set
+	 */
+	public void setMotorReadbackResolution(double motorReadbackResolution) {
+		this.motorReadbackResolution = motorReadbackResolution;
+	}
+
+	/**
+	 * @return the motorEncoderResolution
+	 */
+	public double getMotorEncoderResolution() {
+		return motorEncoderResolution;
+	}
+
+	/**
+	 * @param motorEncoderResolution the motorEncoderResolution to set
+	 */
+	public void setMotorEncoderResolution(double motorEncoderResolution) {
+		this.motorEncoderResolution = motorEncoderResolution;
+	}
+
+	/**
+	 * @return the encoderOffset
+	 */
+	public double getEncoderOffset() {
+		return encoderOffset;
+	}
+
+	/**
+	 * @param encoderOffset the encoderOffset to set
+	 */
+	public void setEncoderOffset(double encoderOffset) {
+		this.encoderOffset = encoderOffset;
+	}
+
+	/**
+	 * @return the encoderResolution
+	 */
+	public double getEncoderResolution() {
+		return encoderResolution;
+	}
+
+	/**
+	 * @param encoderResolution the encoderResolution to set
+	 */
+	public void setEncoderResolution(double encoderResolution) {
+		this.encoderResolution = encoderResolution;
+	}
+
+	/**
+	 * @return the encoderDirection
+	 */
+	public int getEncoderDirection() {
+		return encoderDirection;
+	}
+
+	/**
+	 * @param encoderDirection the encoderDirection to set
+	 */
+	public void setEncoderDirection(int encoderDirection) {
+		this.encoderDirection = encoderDirection;
+	}
+
+	
+	/**
+	 * @return the start
+	 */
+	public double getStart() {
+		return start;
+	}
+
+	/**
+	 * @param start the start to set
+	 */
+	public void setStart(double start) {
+		this.start = start;
+		if(start<=end){
+			positive=true;
+		}
+		else{
+			positive=false;
+		}
+	}
+
+	/**
+	 * @return the end
+	 */
+	public double getEnd() {
+		return end;
+	}
+
+	/**
+	 * @param end the end to set
+	 */
+	public void setEnd(double end) {
+		this.end = end;
+		if(end>=start){
+			positive=true;
+		}
+		else{
+			positive=false;
+		}
+	}
+	
+	/**
+	 * Calculate real position
+	 * @param raw
+	 * @return
+	 */
+	public double calculatePositionMotor(double raw){
+		return(((raw * motorResolution * motorReadbackResolution)/motorDirection)+motorOffset);
+	}
+	
+	/**
+	 * Calculate real motor position using the readback link
+	 * @param raw
+	 * @return
+	 */
+	public double calculatePositionMotorUseReadback(double raw){
+		return((((raw - encoderOffset) * encoderResolution * encoderDirection * motorReadbackResolution) / motorDirection) + motorOffset);
+	}
+	
+	/**
+	 * Calculate real motor position using encoder
+	 * @param raw
+	 * @return
+	 */
+	public double calculatePositionMotorUseEncoder(double raw){
+		return(raw * motorEncoderResolution * motorReadbackResolution/motorDirection + motorOffset);
+	}
+	
+	/**
+	 * Filter whether value is with the range
+	 * @param value
+	 * @return
+	 */
+	public boolean filter(Double value){
+		if(positive){
+			if(start<=value && value<=end){
+				
+				// If motor is very accurete and user backlash==null it might be that value is exactly 
+				// the end value. To prevent that unnecessary data is captured execute this check
+				if(wasEqualBefore){
+					wasEqualBefore=false; // Reset flag
+					return false;
+				}
+				
+				// Check whether was equal
+				if(value==end){
+					wasEqualBefore=true;
+				}
+				
+				return true;
+			}
+			else{
+				return false;
+			}
+		}
+		else{
+			if(end<=value && value <=start){
+				
+				if(wasEqualBefore){
+					wasEqualBefore=false; // Reset flag
+					return false;
+				}
+				
+				// Check whether was equal
+				if(value==start){
+					wasEqualBefore=true;
+				}
+				
+				return true;
+			}
+			else{
+				return false;
+			}
+		}
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/CrlogicResource.java

@@ -0,0 +1,71 @@
+/**
+ * 
+ * Copyright 2013 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This code is distributed in the hope that it will be useful, but without any
+ * warranty; without even the implied warranty of merchantability or fitness for
+ * a particular purpose. See the GNU Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+package ch.psi.fda.core.loops.cr;
+
+/**
+ * Readout resource of crlogic
+ */
+public class CrlogicResource {
+	
+	/**
+	 * Id of the data
+	 */
+	private String id;
+	/**
+	 * Id of the crlogic resource to be read out. As configured in the CRLOGIC part of the IOC startup script
+	 */
+	private String key;
+	/**
+	 * Flag whether to read back the delta of the values of this resource. (delta is done in software)
+	 */
+	private boolean delta = false;
+	
+	public CrlogicResource(){
+	}
+	
+	public CrlogicResource(String id, String key){
+		this.id = id;
+		this.key = key;
+	}
+	
+	public CrlogicResource(String id, String key, boolean delta){
+		this.id = id;
+		this.key = key;
+		this.delta = delta;
+	}
+	
+	public String getId() {
+		return id;
+	}
+	public void setId(String id) {
+		this.id = id;
+	}
+	public String getKey() {
+		return key;
+	}
+	public void setKey(String key) {
+		this.key = key;
+	}
+	public boolean isDelta() {
+		return delta;
+	}
+	public void setDelta(boolean delta) {
+		this.delta = delta;
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/MainHeader.java

@@ -0,0 +1,23 @@
+package ch.psi.fda.core.loops.cr;
+
+/**
+ * Header of the ZMQ message
+ */
+public class MainHeader {
+	private String htype;
+	private int elements;
+	
+	public void setElements(int elements) {
+		this.elements = elements;
+	}
+	public int getElements() {
+		return elements;
+	}
+	
+	public void setHtype(String htype) {
+		this.htype = htype;
+	}
+	public String getHtype() {
+		return htype;
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/MergeLogic.java

@@ -0,0 +1,209 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops.cr;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.google.common.eventbus.EventBus;
+import com.google.common.eventbus.Subscribe;
+
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.messages.Message;
+import ch.psi.fda.messages.Metadata;
+
+/**
+ * Class to merge two data streams into one. The secondary queues data is added to the primary queues data.
+ * The resulting queue therefor will hold the same amount of elements as the primary queue does.
+ * The datagroup flag set in the end of stream message will be set according to the flag set in the primary queue.
+ */
+public class MergeLogic {
+
+	private static final Logger logger = Logger.getLogger(MergeLogic.class.getName());
+	
+	private final EventBus primaryEventBus;
+	private final EventBus secondaryEventBus;
+	private final EventBus outputEventBus;
+	
+	private List<Metadata> metadata;
+
+	// Handler of the secondary event bus. We need to keep the reference on this
+	// to be able to unregister ...
+	private Object handler;
+	
+	
+	boolean firstPrimary = true;
+	boolean firstSecondary = true;
+	
+	private BlockingQueue<DataMessage> queue = new LinkedBlockingQueue<>();
+	private List<Object> currentData = null;
+	
+
+	public MergeLogic(EventBus primaryEventBus, EventBus secondaryEventBus, EventBus outputEventBus){
+		this.primaryEventBus = primaryEventBus;
+		this.secondaryEventBus = secondaryEventBus;
+		this.outputEventBus = outputEventBus;
+	}
+	
+	// Enables the merge logic
+	public void enable(){
+		
+		firstPrimary = true;
+		firstSecondary = true;
+		
+		queue.clear();
+		
+		handler = new Object(){
+			@Subscribe
+			public void onMessage(DataMessage m){
+				// Only queue data messages
+				queue.add(m);
+			}
+		};
+		
+		primaryEventBus.register(this);
+		secondaryEventBus.register(handler);
+	}
+	
+	// Disables the merge logic
+	public void disable(){
+		primaryEventBus.unregister(this);
+		secondaryEventBus.unregister(handler);
+		
+		queue.clear();
+	}
+	
+	
+	/**
+	 * This is the master merging logic
+	 * @param m		Data message from primary event bus
+	 */
+	@Subscribe
+	public void onMessage(Message rawMessage){
+		if(rawMessage instanceof EndOfStreamMessage){
+			outputEventBus.post(rawMessage);
+			
+			// Clear queue of secondary event bus 
+			queue.clear();
+			return;
+		}
+		else if(!(rawMessage instanceof DataMessage)){
+			logger.warning("Message type not supported - ignore");
+			return;
+		}
+		
+		DataMessage message = (DataMessage) rawMessage;
+		
+		// Hack to remove the synchronization timestamp from the primary event bus
+		if(firstPrimary){
+			firstPrimary = false;
+			
+			metadata = new ArrayList<>();
+			List<Metadata> pqm = message.getMetadata();
+			metadata.add(pqm.get(0)); // add first component (this is the actuator)
+			// Skip the next component as this is the timestamp used to merge the data
+			for(int i=2;i<pqm.size();i++){
+				metadata.add(pqm.get(i));
+			}
+		}
+		
+		// Merge logic
+		// Get and remove merge timestamp from the data of the message 
+		Double timestamp = (Double) message.getData().remove(1);
+		long milliseconds = (long) (timestamp*1000);
+		long nanoOffset = (long)((timestamp*1000-milliseconds)*1000000);
+		
+		int count = 10;
+		while(true){ // TODO Wait only for a limited amount of time ...
+			// Assumption: the secondary Queue holds at least the data up to the timestamp of the message handled by this function
+			DataMessage msCheck = queue.peek();
+			
+			// No data is available need to wait for some time
+			// If still no data is available, throw an exception 
+			if(msCheck == null){
+				if(count==0){
+					throw new RuntimeException("No data comming in from SCR channels");
+				}
+				
+				if(currentData == null){
+					// Need to wait until data comes in ... (this case is for the beginning only)
+					logger.info("No data available");
+					try {
+						Thread.sleep(10);
+					} catch (InterruptedException e) {
+						logger.log(Level.INFO, "", e);
+					}
+					count--;
+					continue;
+				}
+				else{
+					break;
+				}
+			}
+			
+			
+			// If we handle the first message of the secondary event bus, we copy its metadata 
+			if(firstSecondary){
+				firstSecondary = false;
+					
+				List<Metadata> sqm = msCheck.getMetadata();
+				// Skip first two components of the message as this is the timestamp
+				for(int i=2;i<sqm.size();i++){
+					metadata.add(sqm.get(i));
+				}
+			}
+				
+			// Check whether timestamp of the next message is bigger than the timestamp of the 
+			// message from the primary queue - if the timestamp is bigger do not take message out of the queue
+				
+			long currMilliCheck = ((Double) msCheck.getData().get(0)).longValue();
+			long currNanoCheck = ((Double) msCheck.getData().get(1)).longValue();
+
+			if(currMilliCheck>milliseconds || (currMilliCheck==milliseconds && currNanoCheck>nanoOffset)){
+				break;
+			}
+				
+			try {
+				DataMessage currentDataMessage = queue.take();
+				currentData = currentDataMessage.getData();
+				// Remove timestamps used for synchronization
+				currentData.remove(0);
+				currentData.remove(0);
+			} catch (InterruptedException e) {
+				throw new RuntimeException(e);
+			}
+
+		}
+		
+		if(currentData == null){
+			throw new RuntimeException("No SCR data arrived");
+		}
+			
+		// Add data to primary data queue message and put it into the out queue
+		message.getData().addAll(currentData);
+		message.setMetadata(metadata);
+		outputEventBus.post(message);
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/ParallelCrlogic.java

@@ -0,0 +1,211 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This code is distributed in the hope that it will be useful,
+ * but without any warranty; without even the implied warranty of
+ * merchantability or fitness for a particular purpose. See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops.cr;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.core.Action;
+import ch.psi.fda.core.ActionLoop;
+
+public class ParallelCrlogic implements ActionLoop {
+	
+	private static final Logger logger = Logger.getLogger(ParallelCrlogic.class.getName());
+
+	/**
+	 * Flag to indicate whether the data of this loop will be grouped
+	 * According to this flag the dataGroup flag in EndOfStream will be set.
+	 */
+	private boolean dataGroup = false;
+	
+	private CrlogicLoopStream crlogic;
+	private ScrlogicLoop scrlogic;
+	
+	/**
+	 * List of actions that are executed at the beginning of the loop.
+	 */
+	private List<Action> preActions;
+	/**
+	 * List of actions that are executed at the end of the loop.
+	 */
+	private List<Action> postActions;
+	
+	private MergeLogic mergeLogic;
+	
+	
+	private final EventBus eventbus;
+	
+	public ParallelCrlogic(CrlogicLoopStream crlogic, ScrlogicLoop scrlogic){
+		
+		if(crlogic==null){
+			throw new IllegalArgumentException("No Crloop specified");
+		}
+		if(scrlogic==null){
+			throw new IllegalArgumentException("No Scrloop specified");
+		}
+		
+		
+		this.eventbus = new EventBus();
+		
+		this.crlogic = crlogic;
+		// Add timestamp to sensor at the beginning of the sensor list as this is required for merging the data
+		// Timestamp will be at the second position of a message in the queue!
+		this.crlogic.getSensors().add(0, new CrlogicResource("tmp_timestamp","TIMESTAMP"));
+		this.scrlogic = scrlogic;
+		
+		// Initialize lists used by the loop
+		this.preActions = new ArrayList<Action>();
+		this.postActions = new ArrayList<Action>();
+		
+		
+		
+		this.mergeLogic = new MergeLogic(crlogic.getEventBus(), scrlogic.getEventBus(), eventbus);
+	}
+	
+	@Override
+	public void prepare() {
+	}
+	
+	@Override
+	public void execute() throws InterruptedException {
+		
+		mergeLogic.enable();
+		
+		// Execute pre actions
+		for(Action action: preActions){
+			action.execute();
+		}
+		
+		
+		ExecutorService service = Executors.newFixedThreadPool(3); // 2 for the parallel data acquisition and 1 for the merger thread
+		final CyclicBarrier b = new CyclicBarrier(2);
+		
+		List<Future<Boolean>> list = new ArrayList<Future<Boolean>>();
+		
+		// Start a thread for each logic
+		logger.info("Submit logic");
+		Future<Boolean> f = service.submit(new Callable<Boolean>(){
+			@Override
+			public Boolean call() throws Exception {
+				
+				// Prepare logic
+				crlogic.prepare();
+				
+				// Ensure that really all parallel logics start in parallel
+				b.await();
+				
+				// Execute the logic of this path
+				crlogic.execute();
+	
+//				crlogic.cleanup();
+				
+				// Need to stop the scrlogic logic (otherwise it would keep going to take data)
+				scrlogic.abort();
+				return true;
+			}});
+		list.add(f);
+		
+		//Start a thread for the scrlogic
+		logger.info("Submit logic");
+		f = service.submit(new Callable<Boolean>(){
+			@Override
+			public Boolean call() throws Exception {
+				
+				// Prepare logic
+				scrlogic.prepare();
+				
+				// Ensure that really all parallel logics start in parallel
+				b.await();
+				
+				// Execute the logic of this path
+				scrlogic.execute(); // This actually just starts the collection ...
+				
+//				scrlogic.cleanup();
+				return true;
+			}});
+		list.add(f);
+		
+		for(Future<Boolean> bf: list){
+			// Wait for completion of the thread
+			try {
+				bf.get();
+			} catch (ExecutionException e) {
+				logger.log(Level.WARNING, "Something went wrong while waiting for crthreads to finish");
+				throw new RuntimeException(e);
+			}
+		}
+		
+		// Wait until all threads have finished
+		service.shutdown();
+		service.awaitTermination(1, TimeUnit.MINUTES);
+		
+		
+		// Execute post actions
+		for(Action action: postActions){
+			action.execute();
+		}
+		
+		mergeLogic.disable();
+	}
+
+	@Override
+	public void abort() {
+	}
+
+	@Override
+	public void cleanup() {
+	}
+
+	@Override
+	public List<Action> getPreActions() {
+		return preActions;
+	}
+
+	@Override
+	public List<Action> getPostActions() {
+		return postActions;
+	}
+
+	@Override
+	public boolean isDataGroup() {
+		return dataGroup;
+	}
+
+	@Override
+	public void setDataGroup(boolean dataGroup) {
+		this.dataGroup = dataGroup;
+	}
+
+	@Override
+	public EventBus getEventBus(){
+		return eventbus;
+	}
+}

src/main/java/ch/psi/fda/core/loops/cr/ScrlogicLoop.java

@@ -0,0 +1,224 @@
+/**
+ * 
+ * Copyright 2010 Paul Scherrer Institute. All rights reserved.
+ * 
+ * This code is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ * 
+ * This code is distributed in the hope that it will be useful, but without any
+ * warranty; without even the implied warranty of merchantability or fitness for
+ * a particular purpose. See the GNU Lesser General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this code. If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+package ch.psi.fda.core.loops.cr;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeoutException;
+import java.util.logging.Logger;
+
+import com.google.common.eventbus.EventBus;
+
+import ch.psi.fda.core.Action;
+import ch.psi.fda.core.ActionLoop;
+import ch.psi.fda.messages.DataMessage;
+import ch.psi.fda.messages.EndOfStreamMessage;
+import ch.psi.fda.messages.Metadata;
+import ch.psi.jcae.Channel;
+import ch.psi.jcae.ChannelException;
+import ch.psi.jcae.impl.type.DoubleTimestamp;
+
+/**
+ * Assumptions: - The delay between the monitor writing the value to the monitor
+ * queue and the readout of all the queues is sufficient to prevent the
+ * situation that some monitors of events close to each other on different IOC's
+ * have not arrived yet. - The sequence of monitors fired for one channel is
+ * according to the sequence of the causes. No monitor package is overtaking an
+ * other package on the network.
+ * 
+ * - No monitor events are lost on the network (while using monitors you cannot
+ * guarantee this)
+ * 
+ * The data queue returned by this logic includes two items for the timestamp
+ * and nanoseconds offset. These two items are the first two items of a message
+ * The id's are: crTimestampMilliseconds crTimestampOffsetNanoseconds
+ */
+public class ScrlogicLoop implements ActionLoop {
+
+	private static String ID_TIMESTAMP_MILLISECONDS = "crTimestampMilliseconds";
+	private static String ID_TIMESTAMP_OFFSET_NANOSECONDS = "crTimestampOffsetNanoseconds";
+
+	private static final Logger logger = Logger.getLogger(ScrlogicLoop.class.getName());
+
+	private boolean dataGroup = false;
+	private final List<Action> preActions = new ArrayList<Action>();
+	private final List<Action> postActions = new ArrayList<Action>();
+
+	private final List<Channel<DoubleTimestamp>> sensors;
+	private final List<String> sensorIds;
+
+	/**
+	 * List of monitors that were attached to the sensor channels (i.e
+	 * workaround)
+	 */
+	private final List<PropertyChangeListener> monitors = new ArrayList<>();
+
+	private List<Object> currentValues;
+
+	private CountDownLatch latch;
+
+	private final EventBus eventbus;
+	private List<Metadata> metadata;
+
+	public ScrlogicLoop(List<String> sensorIds, List<Channel<DoubleTimestamp>> sensors) {
+		this.eventbus = new EventBus();
+		this.sensors = sensors;
+		this.sensorIds = sensorIds;
+	}
+
+	@Override
+	public void execute() throws InterruptedException {
+
+		latch = new CountDownLatch(1);
+
+		// Initialize current values
+		currentValues = new ArrayList<Object>(sensors.size() + 2);
+		// Initialize values
+		currentValues.add(0.0);
+		currentValues.add(0.0);
+		for (Channel<DoubleTimestamp> sensor : sensors) {
+			try {
+				DoubleTimestamp value = sensor.getValue();
+				double timestamp = value.getTimestamp().getTime();
+				double noffset = value.getNanosecondOffset();
+				if (timestamp > ((Double) currentValues.get(0))) { 
+					// We don't care about the nanoseconds offset so far
+					currentValues.set(0, timestamp);
+					currentValues.set(1, noffset);
+				}
+				currentValues.add(value.getValue());
+			} catch (InterruptedException | TimeoutException | ChannelException | ExecutionException e) {
+				throw new RuntimeException("Unable to retrieve initial value");
+			}
+			// Initialize current value with NAN
+		}
+
+		// Create metadata
+		metadata = new ArrayList<>(sensors.size());
+
+		// Build up data message metadata based on the channels registered.
+		metadata.add(new Metadata(ID_TIMESTAMP_MILLISECONDS));
+		metadata.add(new Metadata(ID_TIMESTAMP_OFFSET_NANOSECONDS));
+		for (String id : sensorIds) {
+			metadata.add(new Metadata(id));
+		}
+
+		// Send a first data message to be sure that there is a message inside
+		// the queue
+		DataMessage message = new DataMessage(metadata);
+		message.getData().addAll(currentValues);
+
+		eventbus.post(message);
+
+		// Attach monitors to the channels (this is actually a workaround)
+		int counter = 2;
+		for (Channel<DoubleTimestamp> sensor : sensors) {
+			final int currentCount = counter;
+
+			PropertyChangeListener listener = new PropertyChangeListener() {
+
+				@Override
+				public void propertyChange(PropertyChangeEvent evt) {
+					if (evt.getPropertyName().equals("value")) {
+
+						// Merging values this way it is not 100% accurate as
+						// theoretically values does not need to come in
+						// in the correct time sequence. However we tradeoff
+						// this accuracy as we are not precise anyway
+
+						DoubleTimestamp v = (DoubleTimestamp) evt.getNewValue();
+						double timestamp = v.getTimestamp().getTime();
+						double noffset = v.getNanosecondOffset();
+						currentValues.set(0, timestamp);
+						currentValues.set(1, noffset);
+						currentValues.set(currentCount, v.getValue());
+
+						DataMessage message = new DataMessage(metadata);
+						message.getData().addAll(currentValues);
+						// logger.info("update"+v.getValue());
+						eventbus.post(message);
+					}
+				}
+			};
+			sensor.addPropertyChangeListener(listener);
+			monitors.add(listener);
+			
+			counter++;
+		}
+
+		logger.info("Start data acquisition");
+
+		latch.await();
+
+		// Remove monitors
+
+		logger.info("Remove monitors");
+		for (int i = 0; i < sensors.size(); i++) {
+			Channel<DoubleTimestamp> sensor = sensors.get(i);
+			sensor.removePropertyChangeListener(monitors.get(i));
+		}
+
+		// Put end of stream to the queue
+		eventbus.post(new EndOfStreamMessage(dataGroup));
+
+	}
+
+	@Override
+	public void abort() {
+		latch.countDown();
+	}
+
+	@Override
+	public void prepare() {
+	}
+
+	@Override
+	public void cleanup() {
+	}
+
+	@Override
+	public List<Action> getPreActions() {
+		return preActions;
+	}
+
+	@Override
+	public List<Action> getPostActions() {
+		return postActions;
+	}
+
+	@Override
+	public boolean isDataGroup() {
+		return dataGroup;
+	}
+
+	@Override
+	public void setDataGroup(boolean dataGroup) {
+		this.dataGroup = dataGroup;
+	}
+
+	@Override
+	public EventBus getEventBus() {
+		return eventbus;
+	}
+}