initial commit, version 0.4.1 from http://sourceforge.net/projects/libk8055

6 files changed, 1698 insertions, 0 deletions

diff --git a/java/src/c/jk8055.c b/java/src/c/jk8055.c
new file mode 100644
index 0000000..e33de70
--- /dev/null
+++ b/java/src/c/jk8055.c
@@ -0,0 +1,398 @@
+/*  
+ * Copyright (C) 2008 Martin Pischky (mailto:martin@pischky.de)  
+ *
+ * This file (jk8055.c) is part of libk8055/jk8055.
+ * jk8055 - a java wrapper for libk8055
+ *
+ * libk8055/jk8055 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * $Id: jk8055.c,v 1.2 2008/07/12 11:32:01 pischky Exp $
+ * 
+ */
+
+#include <jni.h>
+#ifdef USE_VELLEMAN_DLL
+    // assumes that Velleman DLL Version 2 has been installed
+    #define bool int
+    #include <K8055D_C.h> 
+#else
+    // assumes that the c library as been installed with header file
+    #include <k8055.h> 
+#endif 
+#include <stdio.h>
+#include "jk8055.h"
+
+#define K8055_ERROR -1
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    COpenDevice
+ * Signature: (I)I
+ */
+JNIEXPORT jint 
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_COpenDevice
+(JNIEnv* env, jobject obj, jint cardAddress)
+{
+	return OpenDevice(cardAddress);
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CCloseDevice
+ * Signature: ()I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CCloseDevice
+(JNIEnv* env, jobject obj)
+{
+	return CloseDevice();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CReadAnalogChannel
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CReadAnalogChannel
+(JNIEnv* env, jobject obj, jint channel)
+{
+	return ReadAnalogChannel( channel );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CReadAllAnalog
+ * Signature: (Lnet/sf/libk8055/jk8055/JK8055$AllAnalog;)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CReadAllAnalog
+(JNIEnv* env, jobject obj, jobject data)
+{
+	long a1, a2;
+	jfieldID fid1, fid2;
+	int retval;
+	jclass cls;
+
+	retval = ReadAllAnalog( &a1, &a2 );
+	if( retval == K8055_ERROR ) return retval;
+	cls = (*env)->GetObjectClass( env, data );
+	fid1 = (*env)->GetFieldID( env, cls, "data1", "I" );
+	if( fid1 == NULL ) return K8055_ERROR;
+	fid2 = (*env)->GetFieldID( env, cls, "data2", "I" );
+	if( fid2 == NULL ) return K8055_ERROR;
+	(*env)->SetIntField( env, data, fid1, (jint) a1 );
+	(*env)->SetIntField( env, data, fid2, (jint) a2 );
+	return 0;
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    COutputAnalogChannel
+ * Signature: (II)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_COutputAnalogChannel
+(JNIEnv* env, jobject obj, jint channel, jint data)
+{
+	return OutputAnalogChannel( channel, data );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    COutputAllAnalog
+ * Signature: (II)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_COutputAllAnalog
+(JNIEnv* env, jobject obj, jint data1, jint data2)
+{
+	return OutputAllAnalog( data1, data2 );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CClearAllAnalog
+ * Signature: ()I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CClearAllAnalog
+(JNIEnv* env, jobject obj)
+{
+	return ClearAllAnalog();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CClearAnalogChannel
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CClearAnalogChannel
+(JNIEnv* env, jobject obj, jint channel)
+{
+	return ClearAnalogChannel( channel );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetAnalogChannel
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetAnalogChannel
+(JNIEnv* env, jobject obj, jint channel)
+{
+	return SetAnalogChannel( channel );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetAllAnalog
+ * Signature: ()I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetAllAnalog
+(JNIEnv* env, jobject obj)
+{
+	return SetAllAnalog();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CWriteAllDigital
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CWriteAllDigital
+(JNIEnv* env, jobject obj, jint data)
+{
+	return WriteAllDigital( data );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CClearDigitalChannel
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CClearDigitalChannel
+(JNIEnv* env, jobject obj, jint channel)
+{
+	return ClearDigitalChannel( channel );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CClearAllDigital
+ * Signature: ()I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CClearAllDigital
+(JNIEnv* env, jobject obj)
+{
+	return ClearAllDigital();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetDigitalChannel
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetDigitalChannel
+(JNIEnv* env, jobject obj, jint channel)
+{
+	return SetDigitalChannel( channel );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetAllDigital
+ * Signature: ()I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetAllDigital
+(JNIEnv* env, jobject obj)
+{
+	return SetAllDigital();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CReadDigitalChannel
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CReadDigitalChannel
+(JNIEnv* env, jobject obj, jint channel)
+{
+	return ReadDigitalChannel( channel );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CReadAllDigital
+ * Signature: ()I
+ */
+JNIEXPORT jint 
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CReadAllDigital
+(JNIEnv* env, jobject obj)
+{
+	return ReadAllDigital();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CResetCounter
+ * Signature: (I)I
+ */
+JNIEXPORT jint 
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CResetCounter
+(JNIEnv* env, jobject obj, jint counterno)
+{
+	return ResetCounter( counterno );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CReadCounter
+ * Signature: (I)I
+ */
+JNIEXPORT jint 
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CReadCounter
+(JNIEnv* env, jobject obj, jint counterno)
+{
+	return ReadCounter( counterno ); 
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetCounterDebounceTime
+ * Signature: (II)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetCounterDebounceTime
+(JNIEnv* env, jobject obj, jint counterno, jint debouncetime)
+{
+	return SetCounterDebounceTime( counterno, debouncetime );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CReadAllValues
+ * Signature: (Lnet/sf/libk8055/jk8055/JK8055$AllValues;)I
+ */
+JNIEXPORT jint 
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CReadAllValues
+(JNIEnv* env, jobject obj, jobject av)
+{
+	long input, analog1, analog2, counter1, counter2;
+	int retval;
+	jfieldID fid_input, fid_analog1, fid_analog2, fid_counter1, fid_counter2;
+	jclass cls;
+
+    #ifdef USE_VELLEMAN_DLL
+        input = ReadAllDigital();
+        if( input == K8055_ERROR ) return input;
+        retval = ReadAllAnalog( &analog1, &analog2 );
+        if( retval == K8055_ERROR ) return retval;
+        counter1 = ReadCounter( 1 );
+        if( counter1 == K8055_ERROR ) return counter1;
+        counter2 = ReadCounter( 2 );
+        if( counter2 == K8055_ERROR ) return counter2;
+    #else
+        retval = ReadAllValues( &input, &analog1, &analog2, &counter1, &counter2 );
+        if( retval == K8055_ERROR ) return retval;
+    #endif
+	cls = (*env)->GetObjectClass( env, av );
+	fid_input = (*env)->GetFieldID( env, cls, "input", "I" );
+	if( fid_input == NULL ) return K8055_ERROR;	
+	fid_analog1 = (*env)->GetFieldID( env, cls, "analog1", "I" );
+	if( fid_analog1 == NULL ) return K8055_ERROR;
+	fid_analog2 = (*env)->GetFieldID( env, cls, "analog2", "I" );
+	if( fid_analog2 == NULL ) return K8055_ERROR;
+	fid_counter1 = (*env)->GetFieldID( env, cls, "counter1", "I" );
+	if( fid_counter1 == NULL ) return K8055_ERROR;
+	fid_counter2 = (*env)->GetFieldID( env, cls, "counter2", "I" );
+	if( fid_counter2 == NULL ) return K8055_ERROR;
+	(*env)->SetIntField( env, av, fid_input, (jint) input );
+	(*env)->SetIntField( env, av, fid_analog1, (jint) analog1 );
+	(*env)->SetIntField( env, av, fid_analog2, (jint) analog2 );
+	(*env)->SetIntField( env, av, fid_counter1, (jint) counter1 );
+	(*env)->SetIntField( env, av, fid_counter2, (jint) counter2 );
+	return 0;
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetAllValues
+ * Signature: (III)I
+ */
+JNIEXPORT jint 
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetAllValues
+(JNIEnv* env, jobject obj, jint digitaldata, jint analogdata1, jint analogdata2)
+{
+    int retval;
+    #ifdef USE_VELLEMAN_DLL
+        retval = WriteAllDigital( digitaldata );
+        if( retval == K8055_ERROR ) return retval;
+        retval = OutputAllAnalog( analogdata1, analogdata2 );
+        if( retval == K8055_ERROR ) return retval;
+    #else    
+	    retval = SetAllValues( digitaldata, analogdata1, analogdata2 );
+	#endif
+	return retval;
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSetCurrentDevice
+ * Signature: (I)I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSetCurrentDevice
+(JNIEnv* env, jobject obj, jint deviceno)
+{
+	return SetCurrentDevice( deviceno );
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CSearchDevices
+ * Signature: ()I
+ */
+JNIEXPORT jint
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CSearchDevices
+(JNIEnv* env, jobject obj)
+{
+	return SearchDevices();
+}
+
+/*
+ * Class:     net_sf_libk8055_jk8055_JK8055
+ * Method:    CVersion
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring
+JNICALL Java_net_sf_libk8055_jk8055_JK8055_CVersion
+(JNIEnv* env, jobject obj)
+{
+    #ifdef USE_VELLEMAN_DLL
+        return (*env)->NewStringUTF( env, "unknown" );
+    #else
+	    return (*env)->NewStringUTF( env, Version() );
+	#endif 
+}
diff --git a/java/src/java/net/sf/libk8055/jk8055/JK8055.java b/java/src/java/net/sf/libk8055/jk8055/JK8055.java
new file mode 100644
index 0000000..26cdbc1
--- /dev/null
+++ b/java/src/java/net/sf/libk8055/jk8055/JK8055.java
@@ -0,0 +1,812 @@
+/*  
+ * Copyright (C) 2008 Martin Pischky (mailto:martin@pischky.de)  
+ *
+ * This file (JK8055.java) is part of libk8055/jk8055.
+ * jk8055 - a java wrapper for libk8055
+ *
+ * libk8055/jk8055 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * $Id: JK8055.java,v 1.4 2008/07/28 09:58:30 pischky Exp $
+ * 
+ */
+
+package net.sf.libk8055.jk8055;
+
+/**
+ * JK8055 - A java wrapper for libk8055.
+ * 
+ * @see <a href="http://libk8055.sourceforge.net/">http://libk8055.sourceforge.net/</a>
+ * @author <a href="mailto:martin@pischky.de">Martin Pischky</a>
+ *
+ */
+public class JK8055 {
+	
+	public static final String CVS_ID = "$Id: JK8055.java,v 1.4 2008/07/28 09:58:30 pischky Exp $";
+	
+	/**
+	 * This class is singleton.
+	 */
+	private JK8055() {
+	}
+	
+	private static JK8055 instance = null;
+	
+	/**
+	 * Create an instance if needed and return it.
+	 * @return the instance
+	 */
+	public static JK8055 getInstance() {
+		if( instance != null ) {
+			return instance;
+		}
+		synchronized (JK8055.class) {
+			if( instance == null ) {
+				instance = new JK8055();
+			}            
+		}
+		return instance;
+	}
+	
+	public static final int K8055_ERROR = -1;
+	
+	static {
+		System.loadLibrary("jk8055");
+	}
+	
+	/* (non-Javadoc)
+	  * @see java.lang.Object#finalize()
+	 */
+	protected void finalize() throws Throwable {
+		try {
+			CloseAllOpenDevices();
+		} finally {
+			super.finalize();
+		}
+	}
+	
+	/**
+	 * Open device.
+	 * Scan through usb busses looking 
+	 * for the right device, claim it and then open the device.
+	 * @param cardAddress
+	 * @return BoardAddress or K8055_ERROR
+	 */
+	private native int COpenDevice( int cardAddress );
+	
+	/**
+	 * Opens the communication link to the K8055 device.
+	 * Opens the communication link to the K8055 card. Loads the drivers 
+	 * needed to communicate via the USB port. This procedure must be performed
+	 * before any attempts to communicate with the K8055 card.
+	 * <br>
+	 * This function can also be used to selects the active K8055 card to read
+	 * and write the data. All the communication routines after this function 
+	 * call are addressed to this card until the other card is selected by this 
+	 * function call.
+	 * 
+	 * @param cardAddress Value between 0 and 3 which corresponds to the 
+	 *                    jumper (SK5, SK6) setting on the K8055 board.
+	 * @return If succeeded the return value will be the card address read 
+	 *         from the K8055 hardware.
+	 * @throws JK8055Exception indicates that K8055 card was not found.
+	 */
+	public synchronized int OpenDevice( int cardAddress ) 
+	throws JK8055Exception
+	{
+		if( cardAddress<0 || 3<cardAddress ) {
+			throw new IllegalArgumentException( "cardAddress: "+cardAddress );
+		}
+		int retval = COpenDevice( cardAddress );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "OpenDevice("+cardAddress+") failed" );
+		}
+		return retval;
+	}
+	
+	/**
+	 * Close the Current device.
+	 * @return retunvalue from usb_close: 0 on success or < 0 on error.
+	 */
+	private native int CCloseDevice();
+	
+	/**
+	 * Closes the link to the K8055 device.
+	 * Unloads the communication routines for K8055 card and unloads the driver 
+	 * needed to communicate via the USB port. This is the last action of the 
+	 * application program before termination.
+	 * 
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized void CloseDevice() 
+	throws JK8055Exception 
+	{
+		int retval = CCloseDevice();
+		if( retval<0 ) {
+			throw new JK8055Exception( "CloseDevice failed with rc="+retval );
+		}
+	}
+	
+	/**
+	 * Close all open devices.
+	 * Check what open devices still exist an closes them.
+	 *
+	 * @throws JK8055Exception 
+	 */
+	public synchronized void CloseAllOpenDevices()
+	throws JK8055Exception
+	{
+		for( int i = 0; i < 4; i++ ) {
+			if( CSetCurrentDevice( i ) != K8055_ERROR ) {
+				CloseDevice();
+			}
+		}
+	} 
+	
+	/**
+	 * @param channel 1..2
+	 * @return 0..255 or K8055_ERROR
+	 */
+	private native int CReadAnalogChannel( int channel );
+	
+	/**
+	 * Reads the status of one analogue input-channel.
+	 * The input voltage of the selected 8-bit Analogue to Digital converter 
+	 * channel is converted to a value which lies between 0 and 255.
+	 * 
+	 * @param channel Value between 1 and 2 which corresponds to the AD channel 
+	 *                whose status is to be read.
+	 * @return The corresponding Analogue to Digital Converter data is read.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid channel number.
+	 */
+	public synchronized int ReadAnalogChannel( int channel ) 
+	throws JK8055Exception 
+	{
+		if( channel<1 || 2<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		int retval = CReadAnalogChannel( channel );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ReadAnalogChannel failed" );
+		}
+		return retval;
+	}
+	
+	public class AllAnalog {
+		public int data1;
+		public int data2;
+	}
+	
+	/**
+	 * @param data
+	 * @return 0 or K8055_ERROR
+	 */
+	private native int CReadAllAnalog(AllAnalog data);
+	
+	/**
+	 * Reads the status of both analogue input-channels.
+	 * The status of both Analogue to Digital Converters are read to a new
+	 * object of class AllAnalogarray 
+	 * 
+	 * @return the values read
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized AllAnalog ReadAllAnalog() 
+	throws JK8055Exception 
+	{
+		AllAnalog aa = new AllAnalog();
+		int retval = CReadAllAnalog( aa );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ReadAllAnalog failed" );
+		}
+		return aa;
+	}
+	
+	/**
+	 * @param channel 1..2
+	 * @param data 0..255
+	 * @return K8055_ERROR or 0
+	 */
+	private native int COutputAnalogChannel( int channel, int data );
+	
+	/**
+	 * Sets the analogue output channel according to the data.
+	 * The indicated 8-bit Digital to Analogue Converter channel is altered 
+	 * according to the new data. This means that the data corresponds to a 
+	 * specific voltage. The value 0 corresponds to a minimum output voltage 
+	 * (0 Volt) and the value 255 corresponds to a maximum output voltage 
+	 * (+5V). A value of 'Data' lying in between these extremes can be 
+	 * translated by the following formula : Data / 255 x 5V.
+	 * 
+	 * @param channel Value between 1 and 2 which corresponds to the 8-bit DA 
+	 *                channel number whose data is to be set.
+	 * @param data    Value between 0 and 255 which is to be sent to the 8-bit 
+	 *                Digital to Analogue Converter.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized void OutputAnalogChannel( int channel, int data ) 
+	throws JK8055Exception 
+	{
+		if( channel<1 || 2<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		if( data<0 || 255<data ) {
+			throw new IllegalArgumentException( "data: "+data );
+		}
+		int retval = COutputAnalogChannel( channel, data );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "OutputAnalogChannel failed" );
+		}
+	}
+	
+	/**
+	 * @param data1 0..255
+	 * @param data2 0..255
+	 * @return K8055_ERROR or 0
+	 */
+	private native int COutputAllAnalog( int data1, int data2 );
+	
+	/**
+	 * Sets both analogue output channels according to the data.
+	 * Both 8-bit Digital to Analogue Converter channels are altered according 
+	 * to the new data. This means that the data corresponds to a specific 
+	 * voltage. The value 0 corresponds to a minimum output voltage (0 Volt) 
+	 * and the value 255 corresponds to a maximum output voltage (+5V). A 
+	 * value of 'Data1' or 'Data2' lying in between these extremes can be 
+	 * translated by the following formula : Data / 255 x 5V.
+	 * 
+	 * @param data1 Value between 0 and 255 which is to be sent to the 8-bit 
+	 *              Digital to Analogue Converter.
+	 * @param data2 Value between 0 and 255 which is to be sent to the 8-bit 
+	 *              Digital to Analogue Converter.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized void OutputAllAnalog( int data1, int data2 ) 
+	throws JK8055Exception 
+	{
+		if( data1<0 || 255<data1 ) {
+			throw new IllegalArgumentException( "data1: "+data1 );
+		}
+		if( data2<0 || 255<data2 ) {
+			throw new IllegalArgumentException( "data2: "+data2 );
+		}
+		int retval = COutputAllAnalog( data1, data2 );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "OutputAllAnalog failed" );
+		}
+	}
+	
+	/**
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CClearAllAnalog();
+	
+	/**
+	 * Sets all analogue output channels to minimum.
+	 * Both DA-channels are set to minimum output voltage (0 Volt) .
+	 * 
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized void ClearAllAnalog() 
+	throws JK8055Exception 
+	{
+		int retval = CClearAllAnalog(); 
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ClearAllAnalog failed" );
+		}
+	}
+	
+	/**
+	 * @param channel 1..2
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CClearAnalogChannel( int channel );
+	
+	/**
+	 * Sets the analogue output channel to minimum.
+	 * The selected DA-channel is set to minimum output voltage (0 Volt).
+	 * 
+	 * @param channel Value between 1 and 2 which corresponds to the 8-bit DA 
+	 *                channel number in which the data is to be erased.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid channel number.
+	 */
+	public synchronized void ClearAnalogChannel( int channel ) 
+	throws JK8055Exception 
+	{
+		if( channel<1 || 2<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		int retval = CClearAnalogChannel( channel );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ClearAllAnalog failed" );
+		}
+	}
+	
+	/**
+	 * @param channel 1..2
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CSetAnalogChannel( int channel );
+	
+	/**
+	 * Sets the analogue output channel to maximum.
+	 * The selected 8-bit Digital to Analogue Converter channel is set to 
+	 * maximum output voltage.
+	 * 
+	 * @param channel Value between 1 and 2 which corresponds to the 8-bit DA 
+	 *                channel number in which the data is to be set to maximum.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid channel number.
+	 */
+	public synchronized void SetAnalogChannel( int channel ) 
+	throws JK8055Exception 
+	{
+		if( channel<1 || 2<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		int retval = CSetAnalogChannel( channel );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetAnalogChannel failed" );
+		}
+	}
+	
+	/**
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CSetAllAnalog();
+	
+	/**
+	 * Sets all analogue output channels to maximum.
+	 * All channels of the 8-bit Digital to Analogue Converters are set to 
+	 * maximum output voltage.
+	 * 
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized void SetAllAnalog() 
+	throws JK8055Exception 
+	{
+		int retval = CSetAllAnalog(); 
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetAllAnalog failed" );
+		}
+	}
+	
+	/**
+	 * @param data 0..255
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CWriteAllDigital( int data );
+	
+	/**
+	 * Sets the digital outputs according to the data.
+	 * The channels of the digital output port are updated with the status of 
+	 * the corresponding bits in the data parameter. A high (1) level means 
+	 * that the microcontroller IC1 output is set, and a low (0) level means
+	 * that the output is cleared.
+	 * 
+	 * @param data Value between 0 and 255 that is sent to the output 
+	 *        port (8 channels).
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized void WriteAllDigital( int data ) 
+	throws JK8055Exception
+	{
+		if( data<0 || 255<data ) {
+			throw new IllegalArgumentException( "data: "+data );
+		}
+		int retval = CWriteAllDigital( data );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "WriteAllDigital failed" );
+		}
+	}
+	
+	/**
+	 * @param channel 1..8
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CClearDigitalChannel( int channel );
+	
+	/**
+	 * Clears the output channel.
+	 * The selected channel is cleared.
+	 * 
+	 * @param channel Value between 1 and 8 which corresponds to the output 
+	 *                channel that is to be cleared.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid channel number.
+	 */
+	public synchronized void ClearDigitalChannel( int channel )
+	throws JK8055Exception
+	{
+		if( channel<1 || 8<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		int retval = CClearDigitalChannel( channel );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ClearDigitalChannel failed" );
+		}
+	}
+	
+	/**
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CClearAllDigital();
+	
+	/**
+	 * Clears all output channels.
+	 * All digital outputs are cleared.
+	 * 
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized void ClearAllDigital()
+	throws JK8055Exception
+	{
+		int retval = CClearAllDigital();
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ClearAllDigital failed" );
+		}
+	}
+	
+	/**
+	 * @param channel 1..8
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CSetDigitalChannel( int channel );
+	
+	/**
+	 * Sets the output channel.
+	 * The selected digital output channel is set.
+	 * 
+	 * @param channel Value between 1 and 8 which corresponds to the output 
+	 *                channel that is to be set.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid channel number.
+	 */
+	public synchronized void SetDigitalChannel( int channel )
+	throws JK8055Exception
+	{
+		if( channel<1 || 8<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		int retval = CSetDigitalChannel( channel );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetDigitalChannel failed" );
+		}
+	}
+	
+	/**
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CSetAllDigital();
+	
+	/**
+	 * Sets all output channels.
+	 * All the digital output channels are set.
+	 * 
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized void SetAllDigital()
+	throws JK8055Exception
+	{
+		int retval = CSetAllDigital();
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetAllDigital failed" );
+		}
+	}
+	
+	/**
+	 * @param channel 1..5
+	 * @return K8055_ERROR or 0,1
+	 */
+	private native int CReadDigitalChannel( int channel );
+	
+	/**
+	 * Reads the status of the input channel.
+	 * The status of the selected Input channel is read.
+	 * 
+	 * @param channel Value between 1 and 5 which corresponds to the input 
+	 *                channel whose status is to be read.
+	 * @return TRUE means that the channel has been set and FALSE means that 
+	 *         it has been cleared.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid channel number.
+	 */
+	public synchronized boolean ReadDigitalChannel( int channel )
+	throws JK8055Exception
+	{
+		if( channel<1 || 5<channel ) {
+			throw new IllegalArgumentException( "channel: "+channel );
+		}
+		int retval = CReadDigitalChannel( channel );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ReadDigitalChannel failed" );
+		}
+		return retval != 0;
+	}
+	
+	/**
+	 * @return K8055_ERROR or 0..31
+	 */
+	private native int CReadAllDigital();
+	
+	/**
+	 * Reads the status of all the input channels.
+	 * The function returns the status of the digital inputs.
+	 * 
+	 * @return The 5 LSB correspond to the status of the input channels. A high 
+	 *         (1) means that the channel is HIGH, a low (0) means that the 
+	 *         channel is LOW.
+	 * @throws JK8055Exception indicates an error.
+	 */
+	public synchronized int ReadAllDigital()
+	throws JK8055Exception
+	{
+		int retval = CReadAllDigital();
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ReadAllDigital failed" );
+		}
+		return retval;
+	}
+
+	/**
+	 * @param counterno 1..2
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CResetCounter( int counterno );
+	
+	/**
+	 * Resets the 16 bit pulse counter number 1 or counter number 2.
+	 * The selected pulse counter is reset.
+	 * 
+	 * @param counterno Value 1 or 2, which corresponds to the counter to 
+	 *                  be reset.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid counter number.
+	 */
+	public synchronized void ResetCount( int counterno ) 
+	throws JK8055Exception
+	{
+		if( counterno<1 || 2<counterno ) {
+			throw new IllegalArgumentException( "counterno: "+counterno );
+		}
+		int retval = CResetCounter( counterno );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ResetCount failed" );
+		}
+	}
+	
+	/**
+	 * @param counterno 1..2
+	 * @return K8055_ERROR or 0..65535
+	 */
+	private native int CReadCounter( int counterno );
+	
+	/**
+	 * Reads the content of the pulse counter number 1 or counter number 2.
+	 * The function returns the status of the selected 16 bit pulse counter.
+	 * <br>
+	 * The counter number 1 counts the pulses fed to the input I1 and the 
+	 * counter number 2 counts the pulses fed to the input I2.
+	 * 
+	 * @param counterno Value 1 or 2, which corresponds to the counter to be 
+	 *                  read.
+	 * @return The content of the 16 bit pulse counter.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid counter number.
+	 */
+	public synchronized int ReadCounter( int counterno )
+	throws JK8055Exception
+	{
+		if( counterno<1 || 2<counterno ) {
+			throw new IllegalArgumentException( "counterno: "+counterno );
+		}
+		int retval = CReadCounter( counterno );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ReadCounter failed" );
+		}
+		return retval;
+	}
+	
+	/**
+	 * @param counterno 1..2
+	 * @param debouncetime 0..7450
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CSetCounterDebounceTime( int counterno, int debouncetime );
+	
+	/**
+	 * Sets the debounce time to the pulse counter.
+	 * The counter inputs are debounced in the software to prevent false 
+	 * triggering when mechanical switches or relay inputs are used. The 
+	 * debounce time is equal for both falling and rising edges. The
+	 * default debounce time is 2ms. This means the counter input must be 
+	 * stable for at least 2ms before it is recognised, giving the maximum 
+	 * count rate of about 200 counts per second.
+	 * <br>
+	 * If the debounce time is set to 0, then the maximum counting rate is 
+	 * about 2000 counts per second.
+	 * 
+	 * @param counterno    Value 1 or 2, which corresponds to the counter 
+	 *                     to be set.
+	 * @param debouncetime (0..7450?) Debounce time for the pulse counter.
+	 *                     <br>
+	 *                     The DebounceTime value corresponds to the debounce 
+	 *                     time in milliseconds (ms) to be set for the
+	 *                     pulse counter. Debounce time value may vary between 
+	 *                     0 and 5000?.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized void SetCounterDebounceTime( int counterno, 
+	                                                 int debouncetime )
+	throws JK8055Exception
+	{
+		if( counterno<1 || 2<counterno ) {
+			throw new IllegalArgumentException( "counterno: "+counterno );
+		}
+		if( debouncetime<0 || 7450<debouncetime ) {
+			throw new IllegalArgumentException( "debouncetime: "+debouncetime );
+		}
+		int retval = CSetCounterDebounceTime( counterno, debouncetime );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetCounterDebounceTime failed" );
+		}
+	}
+	
+	public class AllValues {
+		public int input;
+		public int analog1;
+		public int analog2;
+		public int counter1;
+		public int counter2;
+	}
+	
+	/**
+	 * @param av
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CReadAllValues( AllValues av );
+	
+	/**
+	 * Read all values at once.
+	 * 
+	 * @return an new object of type AllValues
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized AllValues ReadAllValues()
+	throws JK8055Exception 
+	{
+		AllValues av = new AllValues();
+		int retval = CReadAllValues( av );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "ReadAllValues failed" );
+		}
+		return av;
+	}
+	
+	/**
+	 * @param digitaldata 0..255
+	 * @param analogdata1 0..255
+	 * @param analogdata2 0..255
+	 * @return K8055_ERROR or 0
+	 */
+	private native int CSetAllValues( int digitaldata, 
+	                                  int analogdata1, int analogdata2 );
+	
+	/**
+	 * Set all values at once.
+	 * 
+	 * @param digitaldata 0..255
+	 * @param analogdata1 0..255
+	 * @param analogdata2 0..255
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized void SetAllValues( int digitaldata, 
+	                                       int analogdata1, int analogdata2 )
+	throws JK8055Exception
+	{
+		if( digitaldata<1 || 255<digitaldata ) {
+			throw new IllegalArgumentException( "digitaldata: "+digitaldata );
+		}
+		if( analogdata1<1 || 255<analogdata1 ) {
+			throw new IllegalArgumentException( "analogdata1: "+analogdata1 );
+		}
+		if( analogdata2<1 || 255<analogdata2 ) {
+			throw new IllegalArgumentException( "analogdata2: "+analogdata2 );
+		}
+		int retval = CSetAllValues( digitaldata, analogdata1, analogdata2);
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetAllValues failed" );
+		}
+	}
+	
+	/**
+	 * @param deviceno 0..3
+	 * @return K8055_ERROR or 0..3
+	 */
+	private native int CSetCurrentDevice( int deviceno );
+	
+	/**
+	 * The function set the current controlled device. 
+	 * If no device with the address parameter was found.
+	 * an JK8055Exception is thrown.
+	 * 
+	 * @param deviceno Value 0 to 3, which corresponds to the device address.
+	 * @throws JK8055Exception indicates an error.
+	 * @throws IllegalArgumentException indicates an invalid parameter.
+	 */
+	public synchronized void SetCurrentDevice( int deviceno ) 
+	throws JK8055Exception
+	{
+		if( deviceno<0 || 3<deviceno ) {
+			throw new IllegalArgumentException( "deviceno: "+deviceno );
+		}
+		int retval = CSetCurrentDevice( deviceno );
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SetCurrentDevice failed" );
+		}
+	}
+	
+	/**
+	 * @return K8055_ERROR or 0..15
+	 */
+	private native int CSearchDevices();
+	
+	/**
+	 * The function returns all connected devices on the computer.
+	 * The returned value is a bit field.
+	 * <br><b>Note</b>
+	 * <br> Once a specific device address is connected with a program 
+	 * another program can't get access to it.
+	 * 
+	 * @return 
+	 * <pre> 
+	 * Bin 0000, Dec 0 : No devices was found
+	 * Bin 0001, Dec 1 : Card address 0 was found.
+	 * Bin 0010, Dec 2 : Card address 1 was found.
+	 * Bin 0100, Dec 4 : Card address 2 was found.
+	 * Bin 1000, Dec 8 : Card address 3 was found.
+	 * Example : return value 9 = devices with address 0 and 3 are connected.
+	 * </pre>
+	 * @throws JK8055Exception
+	 */
+	public synchronized int SearchDevices()
+	throws JK8055Exception
+	{
+		int retval = CSearchDevices();
+		if( retval == K8055_ERROR ) {
+			throw new JK8055Exception( "SearchDevices failed" );
+		}
+		return retval;
+	}
+	
+	private native String CVersion();
+	
+	/**
+	 * Return the version number of the libk8055 library used.
+	 * 
+	 * @return a string like "0.3"
+	 */
+	public synchronized String Version() {
+		return CVersion();
+	}
+	
+}
diff --git a/java/src/java/net/sf/libk8055/jk8055/JK8055Exception.java b/java/src/java/net/sf/libk8055/jk8055/JK8055Exception.java
new file mode 100644
index 0000000..d0e7104
--- /dev/null
+++ b/java/src/java/net/sf/libk8055/jk8055/JK8055Exception.java
@@ -0,0 +1,73 @@
+/*  
+ * Copyright (C) 2008 Martin Pischky (mailto:martin@pischky.de)  
+ *
+ * This file (JK8055Exception.java) is part of libk8055/jk8055.
+ * jk8055 - a java wrapper for libk8055
+ *
+ * libk8055/jk8055 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * $Id: JK8055Exception.java,v 1.3 2008/07/14 07:47:55 pischky Exp $
+ * 
+ */
+
+package net.sf.libk8055.jk8055;
+
+/**
+ * Exceptions thrown by class JK8055.
+ * 
+ * @author Martin Pischky
+ */
+public class JK8055Exception extends Exception {
+
+	public static final String CVS_ID = "$Id: JK8055Exception.java,v 1.3 2008/07/14 07:47:55 pischky Exp $";
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3821577565947420161L;
+
+	/**
+	 * Constructor.
+	 */
+	public JK8055Exception() {
+		super();
+	}
+
+	/**
+	 * Constructor.
+	 * @param message
+	 */
+	public JK8055Exception(String message) {
+		super(message);
+	}
+
+	/**
+	 * Constructor.
+	 * @param cause
+	 */
+	public JK8055Exception(Throwable cause) {
+		super(cause);
+	}
+
+	/**
+	 * Constructor.
+	 * @param message
+	 * @param cause
+	 */
+	public JK8055Exception(String message, Throwable cause) {
+		super(message, cause);
+	}
+
+}
diff --git a/java/src/java/net/sf/libk8055/jk8055/JK8055Test.java b/java/src/java/net/sf/libk8055/jk8055/JK8055Test.java
new file mode 100644
index 0000000..c2c559c
--- /dev/null
+++ b/java/src/java/net/sf/libk8055/jk8055/JK8055Test.java
@@ -0,0 +1,400 @@
+/*  
+ * Copyright (C) 2008 Martin Pischky (mailto:martin@pischky.de)  
+ *
+ * This file (JK8055Test.java) is part of libk8055/jk8055.
+ * jk8055 - a java wrapper for libk8055
+ *
+ * libk8055/jk8055 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 2 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, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
+ *
+ * $Id: JK8055Test.java,v 1.4 2008/07/14 07:47:55 pischky Exp $
+ * 
+ */
+
+package net.sf.libk8055.jk8055;
+
+import junit.framework.TestCase;
+
+/**
+ * JUnit tests for class JK8055.
+ * 
+ * If you want to run this from eclipse add
+ *   -Djava.library.path=build/c
+ * to VM arguments in run configuration.
+ * 
+ * @author Martin Pischky
+ */
+public class JK8055Test extends TestCase {
+
+	public static final int DEVICE = 0;
+
+	/*
+	 * @see TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	/*
+	 * @see TestCase#tearDown()
+	 */
+	protected void tearDown() throws Exception {
+		super.tearDown();
+	}
+
+	static void sleep( int ms ) {
+		try {
+			Thread.sleep( ms );
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void testGetInstance() {
+		JK8055.getInstance();
+	}
+
+	public void testOpenCloseDevice() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.CloseDevice();
+	}
+
+	public void testReadAnalogChannel() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		int a1 = jk8055.ReadAnalogChannel(1);
+		int a2 = jk8055.ReadAnalogChannel(2);
+		assertTrue("a1>=0",  a1>=0  );
+		assertTrue("a1<=255",a1<=255);
+		assertTrue("a2>=0",  a2>=0  );
+		assertTrue("a2<=255",a2<=255);
+		jk8055.CloseDevice();
+	}
+
+	public void testReadAllAnalog() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		JK8055.AllAnalog aa = jk8055.ReadAllAnalog();
+		assertTrue( "aa.data1>=0",  aa.data1>=0   );
+		assertTrue( "aa.data1<=255",aa.data1<=255 );
+		assertTrue( "aa.data2>=0",  aa.data2>=0   );
+		assertTrue( "aa.data2<=255",aa.data2<=255 );
+		int a1 = jk8055.ReadAnalogChannel(1);
+		int a2 = jk8055.ReadAnalogChannel(2);
+		assertTrue( "a1 ~= aa.data1", Math.abs(a1-aa.data1)<2  );
+		assertTrue( "a2 ~= aa.data2", Math.abs(a2-aa.data2)<2  );
+		jk8055.CloseDevice();
+	}
+
+	public void testOutputAnalogChannel() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.OutputAnalogChannel( 1, 0 );
+		jk8055.OutputAnalogChannel( 2, 255 );
+		sleep( 500 );
+		for (int i = 0; i <= 255; i++) {
+			jk8055.OutputAnalogChannel( 1, i );
+			jk8055.OutputAnalogChannel( 2, 255-i );
+		}
+		for (int i = 255; i >= 0; i--) {
+			jk8055.OutputAnalogChannel( 1, i );
+			jk8055.OutputAnalogChannel( 2, 255-i );
+		}
+		sleep( 500 );
+		jk8055.OutputAnalogChannel( 1, 0 );
+		jk8055.OutputAnalogChannel( 2, 0 );
+		jk8055.CloseDevice();
+	}
+
+	public void testOutputAllAnalog() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.OutputAllAnalog( 0, 255 );
+		sleep( 500 );
+		for (int i = 0; i <= 255; i++) {
+			jk8055.OutputAllAnalog( i, 255-i );
+		}
+		for (int i = 255; i >= 0; i--) {
+			jk8055.OutputAllAnalog( i, 255-i );
+		}
+		sleep( 500 );
+		jk8055.OutputAllAnalog( 0, 0 );
+		jk8055.CloseDevice();
+	}
+
+	public void testClearAllAnalog() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.ClearAllAnalog();
+		jk8055.CloseDevice();
+	}
+
+	public void testClearAnalogChannel() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.ClearAnalogChannel( 1 );
+		jk8055.ClearAnalogChannel( 2 );
+		jk8055.CloseDevice();
+	}
+
+	public void testSetAnalogChannel() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.SetAnalogChannel( 1 );
+		jk8055.SetAnalogChannel( 2 );
+		jk8055.CloseDevice();
+	}
+
+	public void testSetAllAnalog() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.SetAllAnalog();
+		jk8055.CloseDevice();
+	}
+
+	public void testWriteAllDigital() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.WriteAllDigital( 0 );
+		for (int i = 0; i <= 7; i++) {
+			jk8055.WriteAllDigital( 1<<i );
+			sleep( 50 );
+		}
+		for (int i = 7; i >= 0; i--) {
+			jk8055.WriteAllDigital( 1<<i );
+			sleep( 50 );
+		}
+		jk8055.WriteAllDigital( 0 );
+		jk8055.CloseDevice();
+	}
+
+	public void testClearDigitalChannel() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		for (int i = 1; i <= 8; i++) {
+			jk8055.ClearDigitalChannel( i );
+		}
+		jk8055.CloseDevice();
+	}
+
+	public void testClearAllDigital() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.ClearAllDigital();
+		jk8055.CloseDevice();
+	}
+
+	public void testSetDigitalChannel() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		for (int i = 1; i <= 8; i++) {
+			jk8055.SetDigitalChannel( i );
+		}
+		jk8055.CloseDevice();
+	}
+
+	public void testSetAllDigital() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.SetAllDigital();
+		jk8055.CloseDevice();
+	}
+
+	public void testReadDigitalChannel() throws JK8055Exception {
+		System.out.println( "---- testReadDigitalChannel()" );
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		for (int i = 1; i <= 5; i++) {
+			boolean b = jk8055.ReadDigitalChannel( i );
+			System.out.println( "Inp"+i+"="+b );
+		}
+		jk8055.CloseDevice();
+	}
+
+	public void testReadAllDigital() throws JK8055Exception {
+		System.out.println( "---- testReadAllDigital()" );
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		int data = jk8055.ReadAllDigital();
+		assertTrue("data>=0",  data>=0  );
+		assertTrue("data<=255",data<=255);
+		for (int i = 1; i <= 5; i++) {
+			boolean b = (data & (1<<(i-1))) != 0;
+			System.out.println( "Inp"+i+"="+b );
+		}
+		jk8055.CloseDevice();
+	}
+
+	public void testResetCount() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.ResetCount( 1 );
+		jk8055.ResetCount( 2 );
+		jk8055.CloseDevice();
+	}
+
+	public void testReadCounter() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		int c1 = jk8055.ReadCounter( 1 );
+		int c2 = jk8055.ReadCounter( 2 );
+		assertTrue( "c1", 0<=c1 && c1<=65535 );
+		assertTrue( "c2", 0<=c2 && c2<=65535 );
+		jk8055.CloseDevice();
+	}
+
+	public void testSetCounterDebounceTime() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.SetCounterDebounceTime( 1, 1214 );
+		jk8055.SetCounterDebounceTime( 2, 1214 );
+		jk8055.CloseDevice();
+	}
+
+	public void testReadAllValues() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		JK8055.AllValues av = jk8055.ReadAllValues();
+		assertTrue( "av.input>=0",        av.input>=0     );
+		assertTrue( "av.input<=32",       av.input<=32    );
+		assertTrue( "av.analog1>=0",      av.analog1>=0   );
+		assertTrue( "av.analog1<=255",    av.analog2<=255 );
+		assertTrue( "av.analog2>=0",      av.analog2>=0   );
+		assertTrue( "av.analog2<=255",    av.analog2<=255 );
+		assertTrue( "av.counter1>=0",     av.counter1>=0   );
+		assertTrue( "av.counter1<=65535", av.counter1<=65535 );
+		assertTrue( "av.counter2>=0",     av.counter2>=0   );
+		assertTrue( "av.counter2<=65535", av.counter2<=65535 );
+		int a1 = jk8055.ReadAnalogChannel(1);
+		int a2 = jk8055.ReadAnalogChannel(2);
+		assertTrue( "a1 ~= aa.data1", Math.abs(a1-av.analog1)<2  );
+		assertTrue( "a2 ~= aa.data2", Math.abs(a2-av.analog2)<2  );
+		jk8055.CloseDevice();
+	}
+
+	public void testSetAllValues() throws JK8055Exception {
+		JK8055 jk8055 = JK8055.getInstance();
+		jk8055.OpenDevice( DEVICE );
+		jk8055.SetAllValues( 123, 232, 87 );
+		jk8055.CloseDevice();
+	}
+
+	public void testSetCurrentDevice() throws JK8055Exception {
+		System.out.println( "---- testSetCurrentDevice()" );
+		JK8055 jk8055 = JK8055.getInstance();
+		int d = jk8055.SearchDevices();
+		if( d == 0 ) {
+			System.out.println( "No devices found." );
+		} else {
+			for (int i = 0; i <= 3; i++) {
+				if( (d & (1<<i)) != 0 ) {
+					System.out.println( "Device with card address "+i+" was found." );
+				}
+			}
+		}
+		jk8055.CloseDevice(); // required for windows version ?!?
+		for (int i = 0; i <= 3; i++) {
+			if( (d & (1<<i)) != 0 ) {
+				System.out.println( "OpenDevice("+i+")" );
+				jk8055.OpenDevice( i );
+			}
+		}
+		for (int i = 0; i <= 3; i++) {
+			if( (d & (1<<i)) != 0 ) {
+				System.out.println( "SetCurrentDevice("+i+")" );
+				jk8055.SetCurrentDevice( i );
+				System.out.println( "WriteAllDigital("+(1<<i)+")" );
+				jk8055.WriteAllDigital( 1<<i );
+			}
+		}
+		for (int i = 0; i <= 3; i++) {
+			if( (d & (1<<i)) == 0 ) {
+				boolean exThrown = false;
+				try {
+					jk8055.SetCurrentDevice( i );
+				} catch( JK8055Exception ex ) {
+					exThrown = true;
+				}
+				assertTrue( "exThrown", exThrown );
+			}
+		}
+		for (int i = 0; i <= 3; i++) {
+			if( (d & (1<<i)) != 0 ) {
+				System.out.println( "SetCurrentDevice("+i+")" );
+				jk8055.SetCurrentDevice( i );
+				System.out.println( "CloseDevice()" );
+				jk8055.CloseDevice();       
+			}
+		}
+	}
+
+	public void testCloseAllOpenDevices() throws JK8055Exception {
+		System.out.println( "---- testCloseAllOpenDevices()" );
+		JK8055 jk8055 = JK8055.getInstance();
+		int d = jk8055.SearchDevices();
+		if( d == 0 ) {
+			System.out.println( "No devices found." );
+		} else {
+			for (int i = 0; i <= 3; i++) {
+				if( (d & (1<<i)) != 0 ) {
+					System.out.println( "Device with card address "+i+" was found." );
+				}
+			}
+		}
+		jk8055.CloseDevice(); // required for windows version ?!?
+		for (int i = 0; i <= 3; i++) {
+			if( (d & (1<<i)) != 0 ) {
+				System.out.println( "OpenDevice("+i+")" );
+				jk8055.OpenDevice( i );
+			}
+		}
+		for (int i = 0; i <= 3; i++) {
+			if( (d & (1<<i)) != 0 ) {
+				System.out.println( "SetCurrentDevice("+i+")" );
+				jk8055.SetCurrentDevice( i );
+				System.out.println( "WriteAllDigital("+(1<<i)+")" );
+				jk8055.WriteAllDigital( 1<<i );
+			}
+		}
+		jk8055.CloseAllOpenDevices();
+	}
+
+	public void testSearchDevices() throws JK8055Exception {
+		System.out.println( "---- testSearchDevices()" );
+		JK8055 jk8055 = JK8055.getInstance();
+		//jk8055.OpenDevice( DEVICE );
+		// Windows Version (Velleman DDL v2)
+		// does not return devices already opened
+		int d = jk8055.SearchDevices();
+		if( d == 0 ) {
+			System.out.println( "No devices found." );
+		} else {
+			for (int i = 0; i <= 3; i++) {
+				if( (d & (1<<i)) != 0 ) {
+					System.out.println( "Device with card address "+i+" was found." );
+				}
+			}
+		}
+		jk8055.CloseDevice();
+	}
+
+	public void testVersion() {
+		System.out.println( "---- testVersion()" );
+		assertNotNull( JK8055.getInstance().Version() );
+		assertTrue( JK8055.getInstance().Version().length() > 0 );
+		System.out.println( "version=\""+JK8055.getInstance().Version()+"\"" );
+	}
+
+}
diff --git a/java/src/java/net/sf/libk8055/jk8055/overview.html b/java/src/java/net/sf/libk8055/jk8055/overview.html
new file mode 100644
index 0000000..2fff579
--- /dev/null
+++ b/java/src/java/net/sf/libk8055/jk8055/overview.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+<p>
+This document is the API specification for JK8055 - A java wrapper for libk8055.
+</p>
+</body>
+</html>
diff --git a/java/src/java/net/sf/libk8055/jk8055/package.html b/java/src/java/net/sf/libk8055/jk8055/package.html
new file mode 100644
index 0000000..4dba573
--- /dev/null
+++ b/java/src/java/net/sf/libk8055/jk8055/package.html
@@ -0,0 +1,8 @@
+<html>
+<body>
+<p>JK8055 - A java wrapper for libk8055.</p> 
+<p>The wrapper can be used on Linux with libk8055 (see
+<a href="http://libk8055.sourceforge.net/">http://libk8055.sourceforge.net/</a>)
+or the standard Vellemann DLLs on Windows. 
+</body>
+</html>