diff options
Diffstat (limited to 'java')
| -rw-r--r-- | java/build.xml | 213 | ||||
| -rw-r--r-- | java/src/c/jk8055.c | 398 | ||||
| -rw-r--r-- | java/src/java/net/sf/libk8055/jk8055/JK8055.java | 812 | ||||
| -rw-r--r-- | java/src/java/net/sf/libk8055/jk8055/JK8055Exception.java | 73 | ||||
| -rw-r--r-- | java/src/java/net/sf/libk8055/jk8055/JK8055Test.java | 400 | ||||
| -rw-r--r-- | java/src/java/net/sf/libk8055/jk8055/overview.html | 7 | ||||
| -rw-r--r-- | java/src/java/net/sf/libk8055/jk8055/package.html | 8 |
7 files changed, 1911 insertions, 0 deletions
diff --git a/java/build.xml b/java/build.xml new file mode 100644 index 0000000..66dc02c --- /dev/null +++ b/java/build.xml @@ -0,0 +1,213 @@ +<?xml version="1.0"?> +<!-- + * Copyright (C) 2008 Martin Pischky (mailto:martin@pischky.de) + * + * This file (build.xml) 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: build.xml,v 1.4 2008/07/28 09:58:30 pischky Exp $ +--> +<project name="jk8055" default="all"> + <description> + java wrapper for libk8055 + </description> + + <property environment="env" /> + + <!-- some files --> + + <property name="file.base" value="jk8055" /> + <property name="file.c" location="src/c/${file.base}.c" /> + + <property name="version" value="0.3" /> + + <!-- set global properties for building --> + + <property file="build.properties" /> + <property file="${user.home}/build.properties" /> + <!-- example (build.properties is not stored in cvs): + # My installation of M$ VS 2003. + # Use VS 2003 Command Prompt to get the value + VSINSTALLDIR=D:\\Programme\\Visual Studio .NET 2003\\Common7\\IDE + VCINSTALLDIR=D:\\Programme\\Microsoft Visual Studio .NET 2003 + # My installation of the java development kit + jdk.home=D:\\j2sdk1.4.2_11 + # My installation of the Velleman "K8055D_C.lib", "K8055D_C.DLL", + # "K8055D_C.h" and "K8055D.DLL" + VellemanDir=D:\\Programme\\Velleman\\K8055 + --> + + <!-- set properties if not definded in build.properties --> + + <!-- guess java development kit --> + <property name="jdk.home" value="${env.JDK_HOME}" /> + + <!-- guess c compiler for windows (eg.: microsoft visual studio 2003) --> + <property name="VSINSTALLDIR" + location="${env.ProgramFiles}\Microsoft Visual Studio .NET 2003\Common7\IDE" /> + <property name="VCINSTALLDIR" + location="${env.ProgramFiles}\Microsoft Visual Studio .NET 2003" /> + <property name="MSVCDir" + location="${VCINSTALLDIR}\VC7" /> + <property name="DevEnvDir" + location="${VSINSTALLDIR}" /> + <property name="VellemanDir" + location="C:\Program Files\Velleman\K8055" /> + + <target name="init"> + <echo message="running ant '${ant.version}'" level="info" /> + <echo message="on java '${ant.java.version}'" level="info" /> + <echo message="java.home='${java.home}'" level="info" /> + <echo message="jdk.home ='${jdk.home}'" level="info" /> + <mkdir dir="build/java" /> + <mkdir dir="build/c" /> + <mkdir dir="dist" /> + <mkdir dir="dist/win32" /> + <mkdir dir="dist/linux" /> + </target> + + <target name="compile-java" depends="init"> + <javac srcdir="src/java" destdir="build/java"> + <include name="**/*.java"/> + <exclude name="**/*Test.java"/> + </javac> + <javah classpath="build/java" + class="net.sf.libk8055.jk8055.JK8055" + outputfile="build/c/jk8055.h" /> + </target> + + <target name="compile-c" depends="compile-java"> + <javah classpath="build/java" + class="net.sf.libk8055.jk8055.JK8055" + outputfile="build/c/jk8055.h" /> + <exec executable="gcc" dir="build/c" os="Linux"> + <arg line='-o lib${file.base}.so + -shared + -Wl,-soname,lib${file.base}.so + -I${jdk.home}/include + -I${jdk.home}/include/linux + -I. + -lk8055 + "${file.c}"' /> + </exec> + <exec executable="${MSVCDir}\BIN\cl.exe" dir="build/c" + os="Windows 2000, Windows XP" failonerror="true"> + <!-- be carefull with case here ! --> + <env key="Path" path="${DevEnvDir};${MSVCDir}\BIN;${env.Path}" /> + <env key="INCLUDE" path="${MSVCDir}\INCLUDE;${env.INCLUDE}" /> + <env key="LIB" path="${MSVCDir}\LIB;${env.LIB}" /> + <arg line='-I "${jdk.home}\include" + -I "${jdk.home}\include\win32" + -I "${VellemanDir}" + -I. + -DUSE_VELLEMAN_DLL + -LD + "${file.c}" + -Fe${file.base}.dll + -link "${VellemanDir}\K8055D_C.lib"' /> + </exec> + </target> + + <target name="dist" depends="compile-c" + description="create files for distribution"> + <copy todir="dist/linux" failonerror="false"> + <fileset dir="build/c"> + <include name="lib${file.base}.so"/> + </fileset> + </copy> + <copy todir="dist/win32" failonerror="false"> + <fileset dir="build/c"> + <include name="${file.base}.dll"/> + </fileset> + <fileset dir="${VellemanDir}"> + <include name="K8055D_C.DLL"/> + <include name="K8055D.DLL"/> + </fileset> + </copy> + <jar destfile="dist/${file.base}-${version}.jar" basedir="build/java"> + <manifest> + <attribute name="Built-By" value="${user.name}"/> + <attribute name="JK8055-Version" value="${version}"/> + </manifest> + </jar> + </target> + + <target name="javadoc" depends="compile-java" + description="create component Javadoc documentation"> + <mkdir dir="build/docs"/> + <mkdir dir="build/docs/api"/> + <javadoc destdir="build/docs/api" + overview="src/java/net/sf/libk8055/jk8055/overview.html" + packagenames="net.sf.libk8055.jk8055" + author="true" + version="true" + doctitle="<h1>JK8055</h1>" + windowtitle="JK8055 (Version ${version})" + bottom="Copyright &copy; 2008 by Martin Pischky" + use="true" + link="http://java.sun.com/j2se/1.4/docs/api/"> + <fileset dir="src/java"> + <include name="**/*.java"/> + <exclude name="**/*Test.java"/> + </fileset> + </javadoc> + <jar jarfile="dist/${file.base}-${version}-javadoc.jar" + basedir="build/docs/api" /> + </target> + + <target name="junit" depends="compile-c" + description="run junit tests" > + <!-- we assume that junit.jar is in ant's lib directory --> + <mkdir dir="build/reports" /> + <mkdir dir="build/junit" /> + <javac srcdir="src/java" destdir="build/junit"> + <include name="**/*Test.java"/> + </javac> + <junit printsummary="yes" + haltonfailure="yes" showoutput="yes"> + <classpath> + <pathelement location="build/java" /> + <pathelement location="build/junit" /> + <pathelement path="${java.class.path}" /> + </classpath> + <env key="Path" path="build/c;${VellemanDir};${env.Path}"/> + <env key="LD_LIBRARY_PATH" path="build/c:${env.LD_LIBRARY_PATH}"/> + <formatter type="plain"/> + <batchtest fork="yes" todir="build/reports"> + <fileset dir="src/java"> + <include name="**/*Test.java"/> + </fileset> + </batchtest> + </junit> + </target> + + <target name="all" depends="dist, javadoc" + description="--> java wrapper for libk8055"> + </target> + + <target name="clean"> + <delete dir="build"/> + </target> + + <target name="distclean" depends="clean"> + <delete dir="dist"/> + </target> + +</project> + + 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> |