diff options
28 files changed, 5809 insertions, 0 deletions
diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..e647ae1 --- /dev/null +++ b/Makefile @@ -0,0 +1,72 @@ +# $Id: Makefile,v 1.5 2008/05/21 20:22:44 mr_brain Exp $ +# +# Simple makefile for the libk8055 library +# +# change this to your distribution default +# usually /usr/local or /usr +PREFIX = ?/usr/local +CC = gcc +EXEC = k8055 +VERSION =0.4.1 +BINDIR = $(PREFIX)/bin +LIBDIR = $(PREFIX)/lib +PYLIBDIR = pyk8055 +INCLUDEDIR = $(PREFIX)/include +MANDIR = $(PREFIX)/man/man1 +OBJS = main.o libk8055.o +CFLAGS = -O2 -DDAEMON -DVERSION='"$(VERSION)"' -Wall +LIBS = -lusb -L/usr/lib -lm +LINK = ln + +libk8055.so.$(VERSION): libk8055.o + $(CC) -o libk8055.so.${VERSION} $(LIBS) -shared libk8055.o + -$(LINK) -sf libk8055.so.${VERSION} libk8055.so + +libk8055.o: libk8055.c + $(CC) $(CFLAGS) -c -g -fPIC libk8055.c + +libk8055.a: libk8055.o + ar rvs libk8055.a libk8055.o + +libk8055.c: k8055.h + +all: k8055_prog libk8055.so.${VERSION} libk8055.a + +.PHONY: k8055_prog + +k8055_prog: $(OBJS) + $(CC) $(OBJS) -o $(EXEC) $(LIBS) + # strip $(EXEC) + +pylib: $(PYLIBDIR)/libk8055.i libk8055.c + export VERSION=$(VERSION); $(MAKE) -C $(PYLIBDIR) + +clean: + rm -f *.o libk8055.so libk8055.so.$(VERSION) $(EXEC) libk8055.a + @$(MAKE) -C $(PYLIBDIR) clean + +install: k8055_prog libk8055.so.$(VERSION) + cp -f $(EXEC) $(BINDIR)/ + if !(test -d $(LIBDIR)); then \ + mkdir -p $(LIBDIR); \ + fi + if !(test -d $(INCLUDEDIR)); then \ + mkdir -p $(INCLUDEDIR); \ + fi + rm -f $(LIBDIR)/libk8055* + cp -Pf lib* $(LIBDIR) + cp -f k8055.h $(INCLUDEDIR) + if !(test -d $(MANDIR)); then \ + mkdir -p $(MANDIR); \ + fi + cp -f man/k8055.1.gz $(MANDIR)/ + +pyinstall: $(PYLIBDIR)/libk8055.i + @$(MAKE) -C $(PYLIBDIR) install + +uninstall: + rm -f $(BINDIR)/$(EXEC) $(LIBDIR)/libk8055* $(INCLUDEDIR)/k8055.h + +test: k8055_prog + -@killall $(EXEC) + ./$(EXEC) diff --git a/README.txt b/README.txt new file mode 100644 index 0000000..5b5d45c --- /dev/null +++ b/README.txt @@ -0,0 +1,37 @@ +The k8055 require libusb-0.1.9 or newer and kernel 2.4.18 or never. + +install: + # make all + # make install + update ld.so.conf with "/usr/local/lib" if not there or run + env-update at gentoo systems + +uninstall: + # make uninstall + +Check out the Makefile for all different make rules... + +User access to the k8055 device: + read comments in velleman.rules + +Using the k8055 library: + in the program file "#include <k8055.h>" and compile with -lk8055 and + -lusb, e.g gcc -lusb -lk8055 main.c -o k8055_rocks + +Python part + Python makes use of SWIG interface language, for setup and install + see http://www.swig.org + + There might be a prepared package for your distribution, use + emerge swig, apt-get install swig, urpmi swig, rpm -Uvh swig_package + Or whatever your favorite distribution provides. + Then, from the library source directory: + + # make pylib + + You can then run the python programs from within the pyk8055 directory + + For global install, run as root: + # make pyinstall + This should install your package in the proper site-package dircetory + globally accessible for the python interpreter 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> @@ -0,0 +1,55 @@ +/* $Id: k8055.h,v 1.4 2008/05/21 20:25:51 mr_brain Exp $ + + This file is part of the libk8055 Library. + + The libk8055 Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The libk8055 Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU 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. + + http://opensource.org/licenses/ +*/ +#ifdef __cplusplus +extern "C" { +#endif + +/* prototypes */ +int OpenDevice(long board_address); +int CloseDevice(); +long ReadAnalogChannel(long Channelno); +int ReadAllAnalog(long* data1, long* data2); +int OutputAnalogChannel(long channel, long data); +int OutputAllAnalog(long data1,long data2); +int ClearAllAnalog(); +int ClearAnalogChannel(long channel); +int SetAnalogChannel(long channel); +int SetAllAnalog(); +int WriteAllDigital(long data); +int ClearDigitalChannel(long channel); +int ClearAllDigital(); +int SetDigitalChannel(long channel); +int SetAllDigital(); +int ReadDigitalChannel(long channel); +long ReadAllDigital(); +int ResetCounter(long counternr); +long ReadCounter(long counterno); +int SetCounterDebounceTime(long counterno, long debouncetime); +int ReadAllValues (long int *data1, long int *data2, long int *data3, long int *data4, long int *data5); +int SetAllValues(int digitaldata, int addata1, int addata2); +long SetCurrentDevice(long deviceno); +long SearchDevices(void); +char *Version(void); +#ifdef __cplusplus +} +#endif + diff --git a/libk8055.c b/libk8055.c new file mode 100644 index 0000000..9556294 --- /dev/null +++ b/libk8055.c @@ -0,0 +1,600 @@ +/* $Id: libk8055.c,v 1.7 2008/08/20 17:00:55 mr_brain Exp $ + + This file is part of the libk8055 Library. + + The libk8055 Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The libk8055 Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU 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. + + http://opensource.org/licenses/ + + Copyleft (C) 2005 by Sven Lindberg + k8055@k8055.mine.nu + + Copyright (C) 2007 by Pjetur G. Hjaltason + pjetur@pjetur.net + Commenting, general rearrangement of code, bugfixes, + python interface with swig and simple k8055 python class + + + Input packet format + + +---+---+---+---+---+---+---+---+ + |DIn|Sta|A1 |A2 | C1 | C2 | + +---+---+---+---+---+---+---+---+ + DIn = Digital input in high nibble, except for input 3 in 0x01 + Sta = Status, Board number + 1 + A1 = Analog input 1, 0-255 + A2 = Analog input 2, 0-255 + C1 = Counter 1, 16 bits (lsb) + C2 = Counter 2, 16 bits (lsb) + + Output packet format + + +---+---+---+---+---+---+---+---+ + |CMD|DIG|An1|An2|Rs1|Rs2|Dbv|Dbv| + +---+---+---+---+---+---+---+---+ + CMD = Command + DIG = Digital output bitmask + An1 = Analog output 1 value, 0-255 + An2 = Analog output 2 value, 0-255 + Rs1 = Reset counter 1, command 3 + Rs2 = Reset counter 3, command 4 + Dbv = Debounce value for counter 1 and 2, command 1 and 2 + + Or split by commands + + Cmd 0, Reset ?? + Cmd 1, Set debounce Counter 1 + +---+---+---+---+---+---+---+---+ + |CMD| | | | | |Dbv| | + +---+---+---+---+---+---+---+---+ + Cmd 2, Set debounce Counter 2 + +---+---+---+---+---+---+---+---+ + |CMD| | | | | | |Dbv| + +---+---+---+---+---+---+---+---+ + Cmd 3, Reset counter 1 + +---+---+---+---+---+---+---+---+ + | 3 | | | | 00| | | | + +---+---+---+---+---+---+---+---+ + Cmd 4, Reset counter 2 + +---+---+---+---+---+---+---+---+ + | 4 | | | | | 00| | | + +---+---+---+---+---+---+---+---+ + cmd 5, Set analog/digital + +---+---+---+---+---+---+---+---+ + | 5 |DIG|An1|An2| | | | | + +---+---+---+---+---+---+---+---+ + +**/ + +#include <string.h> +#include <stdio.h> +#include <usb.h> +#include <assert.h> +#include <math.h> +#include "k8055.h" + +#define STR_BUFF 256 +#define PACKET_LEN 8 + +#define K8055_IPID 0x5500 +#define VELLEMAN_VENDOR_ID 0x10cf +#define K8055_MAX_DEV 4 + +#define USB_OUT_EP 0x01 /* USB output endpoint */ +#define USB_INP_EP 0x81 /* USB Input endpoint */ + +#define USB_TIMEOUT 20 +#define K8055_ERROR -1 + +#define DIGITAL_INP_OFFSET 0 +#define DIGITAL_OUT_OFFSET 1 +#define ANALOG_1_OFFSET 2 +#define ANALOG_2_OFFSET 3 +#define COUNTER_1_OFFSET 4 +#define COUNTER_2_OFFSET 6 + +#define CMD_RESET 0x00 +#define CMD_SET_DEBOUNCE_1 0x01 +#define CMD_SET_DEBOUNCE_2 0x01 +#define CMD_RESET_COUNTER_1 0x03 +#define CMD_RESET_COUNTER_2 0x04 +#define CMD_SET_ANALOG_DIGITAL 0x05 + +/* set debug to 0 to not print excess info */ +int DEBUG = 0; + +/* variables for usb */ +static struct usb_bus *bus, *busses; +static struct usb_device *dev; + +/* globals for datatransfer */ +struct k8055_dev { + unsigned char data_in[PACKET_LEN+1]; + unsigned char data_out[PACKET_LEN+1]; + struct usb_dev_handle *device_handle; + int DevNo; +}; + +static struct k8055_dev k8055d[K8055_MAX_DEV]; +static struct k8055_dev *CurrDev; + +/* Keep these globals for now */ +unsigned char *data_in, *data_out; + +/* char* device_id[]; */ + +/* Initialize the usb library - only once */ +static void init_usb(void) +{ + static int Done = 0; /* Only need to do this once */ + if (!Done) + { + usb_init(); + usb_find_busses(); + usb_find_devices(); + busses = usb_get_busses(); + Done = 1; + } +} +/* Actual read of data from the device endpoint, retry 3 times if not responding ok */ +static int ReadK8055Data(void) +{ + int read_status = 0, i = 0; + + if (CurrDev->DevNo == 0) return K8055_ERROR; + + for(i=0; i < 3; i++) + { + read_status = usb_interrupt_read(CurrDev->device_handle, USB_INP_EP, (char *)CurrDev->data_in, PACKET_LEN, USB_TIMEOUT); + if ((read_status == PACKET_LEN) && (CurrDev->data_in[1] == CurrDev->DevNo )) return 0; + if (DEBUG) + fprintf(stderr, "Read retry\n"); + } + return K8055_ERROR; +} + +/* Actual write of data to the device endpont, retry 3 times if not reponding correctly */ +static int WriteK8055Data(unsigned char cmd) +{ + int write_status = 0, i = 0; + + if (CurrDev->DevNo == 0) return K8055_ERROR; + + CurrDev->data_out[0] = cmd; + for(i=0; i < 3; i++) + { + write_status = usb_interrupt_write(CurrDev->device_handle, USB_OUT_EP, (char *)CurrDev->data_out, PACKET_LEN, USB_TIMEOUT); + if (write_status == PACKET_LEN) return 0; + if (DEBUG) + fprintf(stderr, "Write retry\n"); + } + return K8055_ERROR; +} + +/* If device is owned by some kernel driver, try to disconnect it and claim the device*/ +static int takeover_device(usb_dev_handle * udev, int interface) +{ + char driver_name[STR_BUFF]; + + memset(driver_name, 0, STR_BUFF); + int ret = K8055_ERROR; + + assert(udev != NULL); + ret = usb_get_driver_np(udev, interface, driver_name, sizeof(driver_name)); + if (ret == 0) + { + if (DEBUG) + fprintf(stderr, "Got driver name: %s\n", driver_name); + if (0 > usb_detach_kernel_driver_np(udev, interface)) + { + if (DEBUG) + fprintf(stderr, "Disconnect OS driver: %s\n", usb_strerror()); + } + else if (DEBUG) + fprintf(stderr, "Disconnected OS driver: %s\n", usb_strerror()); + } + else if (DEBUG) + fprintf(stderr, "Get driver name: - %s\n", usb_strerror()); + + /* claim interface */ + if (usb_claim_interface(udev, interface) < 0) + { + if (DEBUG) + fprintf(stderr, "Claim interface error: %s\n", usb_strerror()); + return K8055_ERROR; + } + else + usb_set_altinterface(udev, interface); + usb_set_configuration(udev, 1); + + if (DEBUG) + { + fprintf(stderr, "Found interface %d\n", interface); + fprintf(stderr, "Took over the device\n"); + } + + return 0; +} + +/* Open device - scan through usb busses looking for the right device, + claim it and then open the device +*/ +int OpenDevice(long BoardAddress) +{ + + int ipid; + + /* init USB and find all of the devices on all busses */ + init_usb(); + + /* ID of the welleman board is 5500h + address config */ + if (BoardAddress >= 0 && BoardAddress < K8055_MAX_DEV) + ipid = K8055_IPID + (int)BoardAddress; + else + return K8055_ERROR; /* throw error instead of being nice */ + + /* start looping through the devices to find the correct one */ + for (bus = busses; bus; bus = bus->next) + { + for (dev = bus->devices; dev; dev = dev->next) + { + if ((dev->descriptor.idVendor == VELLEMAN_VENDOR_ID) && + (dev->descriptor.idProduct == ipid)) + { + CurrDev = &k8055d[BoardAddress]; + CurrDev->device_handle = usb_open(dev); + if (DEBUG) + fprintf(stderr, + "Velleman Device Found @ Address %s Vendor 0x0%x Product ID 0x0%x\n", + dev->filename, dev->descriptor.idVendor, + dev->descriptor.idProduct); + if (takeover_device(CurrDev->device_handle, 0) < 0) + { + if (DEBUG) + fprintf(stderr, + "Can not take over the device from the OS driver\n"); + usb_close(CurrDev->device_handle); /* close usb if we fail */ + return K8055_ERROR; /* throw K8055_ERROR to show that OpenDevice failed */ + } + else + { + CurrDev->DevNo = BoardAddress + 1; /* Mark as open and valid */ + SetCurrentDevice(BoardAddress); + memset(CurrDev->data_out,0,PACKET_LEN); /* Write cmd 0, read data */ + WriteK8055Data(CMD_RESET); + if (ReadK8055Data() == 0) + return BoardAddress; /* This function should return board address */ + else + return K8055_ERROR; + } + } + } + } + if (DEBUG) + fprintf(stderr, "Could not find Velleman k8055 with address %d\n", + (int)BoardAddress); + return K8055_ERROR; +} + +/* Close the Current device */ +int CloseDevice() +{ + int rc; + + if (CurrDev->DevNo == 0) + { + if (DEBUG) + fprintf(stderr, "Current device is not open\n" ); + return 0; + } + rc = usb_close(CurrDev->device_handle); + if (rc >= 0) + { + CurrDev->DevNo = 0; /* Not active nay more */ + CurrDev->device_handle = NULL; + } + return rc; +} + +/* New function in version 2 of Velleman DLL, should return deviceno if OK */ +long SetCurrentDevice(long deviceno) +{ + if (deviceno >= 0 && deviceno < K8055_MAX_DEV) + { + if (k8055d[deviceno].DevNo != 0) + { + CurrDev = &k8055d[deviceno]; + data_in = CurrDev->data_in; + data_out = CurrDev->data_out; + return deviceno; + } + } + return K8055_ERROR; + +} + +/* New function in version 2 of Velleman DLL, should return devices-found bitmask or 0*/ +long SearchDevices(void) +{ + int retval = 0; + init_usb(); + /* start looping through the devices to find the correct one */ + for (bus = busses; bus; bus = bus->next) + { + for (dev = bus->devices; dev; dev = dev->next) + { + if (dev->descriptor.idVendor == VELLEMAN_VENDOR_ID) { + if(dev->descriptor.idProduct == K8055_IPID + 0) retval |= 0x01; + if(dev->descriptor.idProduct == K8055_IPID + 1) retval |= 0x02; + if(dev->descriptor.idProduct == K8055_IPID + 2) retval |= 0x04; + if(dev->descriptor.idProduct == K8055_IPID + 3) retval |= 0x08; + /* else some other kind of Velleman board */ + } + } + } + return retval; +} + +long ReadAnalogChannel(long Channel) +{ + if (Channel == 1 || Channel == 2) + { + if ( ReadK8055Data() == 0) + { + if (Channel == 2) + return CurrDev->data_in[ANALOG_2_OFFSET]; + else + return CurrDev->data_in[ANALOG_1_OFFSET]; + } + else + return K8055_ERROR; + } + else + return K8055_ERROR; +} + +int ReadAllAnalog(long *data1, long *data2) +{ + if (ReadK8055Data() == 0) + { + *data1 = CurrDev->data_in[ANALOG_1_OFFSET]; + *data2 = CurrDev->data_in[ANALOG_2_OFFSET]; + return 0; + } + else + return K8055_ERROR; +} + +int OutputAnalogChannel(long Channel, long data) +{ + if (Channel == 1 || Channel == 2) + { + if (Channel == 2) + CurrDev->data_out[ANALOG_2_OFFSET] = (unsigned char)data; + else + CurrDev->data_out[ANALOG_1_OFFSET] = (unsigned char)data; + + return WriteK8055Data(CMD_SET_ANALOG_DIGITAL); + } + else + return K8055_ERROR; +} + +int OutputAllAnalog(long data1, long data2) +{ + CurrDev->data_out[2] = (unsigned char)data1; + CurrDev->data_out[3] = (unsigned char)data2; + + return WriteK8055Data(CMD_SET_ANALOG_DIGITAL); +} + +int ClearAllAnalog() +{ + return OutputAllAnalog(0, 0); +} + +int ClearAnalogChannel(long Channel) +{ + if (Channel == 1 || Channel == 2) + { + if (Channel == 2) + return OutputAnalogChannel(2, 0); + else + return OutputAnalogChannel(1, 0); + } + else + return K8055_ERROR; +} + +int SetAnalogChannel(long Channel) +{ + if (Channel == 1 || Channel == 2) + { + if (Channel == 2) + return OutputAnalogChannel(2, 0xff); + else + return OutputAnalogChannel(1, 0xff); + } + else + return K8055_ERROR; + +} + +int SetAllAnalog() +{ + return OutputAllAnalog(0xff, 0xff); +} + +int WriteAllDigital(long data) +{ + CurrDev->data_out[1] = (unsigned char)data; + return WriteK8055Data(CMD_SET_ANALOG_DIGITAL); +} + +int ClearDigitalChannel(long Channel) +{ + unsigned char data; + + if (Channel > 0 && Channel < 9) + { + data = CurrDev->data_out[1] & ~(1 << (Channel-1)); + return WriteAllDigital(data); + } + else + return K8055_ERROR; +} + +int ClearAllDigital() +{ + return WriteAllDigital(0x00); +} + +int SetDigitalChannel(long Channel) +{ + unsigned char data; + + if (Channel > 0 && Channel < 9) + { + data = CurrDev->data_out[1] | (1 << (Channel-1)); + return WriteAllDigital(data); + } + else + return K8055_ERROR; +} + +int SetAllDigital() +{ + return WriteAllDigital(0xff); +} + +int ReadDigitalChannel(long Channel) +{ + int rval; + if (Channel > 0 && Channel < 9) + { + if ((rval = ReadAllDigital()) == K8055_ERROR) return K8055_ERROR; + return ((rval & (1 << (Channel-1))) > 0); + } + else + return K8055_ERROR; +} + +long ReadAllDigital() +{ + int return_data = 0; + + if (ReadK8055Data() == 0) + { + return_data = ( + ((CurrDev->data_in[0] >> 4) & 0x03) | /* Input 1 and 2 */ + ((CurrDev->data_in[0] << 2) & 0x04) | /* Input 3 */ + ((CurrDev->data_in[0] >> 3) & 0x18) ); /* Input 4 and 5 */ + return return_data; + } + else + return K8055_ERROR; +} + +int ReadAllValues(long int *data1, long int * data2, long int * data3, long int * data4, long int * data5) +{ + if (ReadK8055Data() == 0) + { + *data1 = ( + ((CurrDev->data_in[0] >> 4) & 0x03) | /* Input 1 and 2 */ + ((CurrDev->data_in[0] << 2) & 0x04) | /* Input 3 */ + ((CurrDev->data_in[0] >> 3) & 0x18) ); /* Input 4 and 5 */ + *data2 = CurrDev->data_in[ANALOG_1_OFFSET]; + *data3 = CurrDev->data_in[ANALOG_2_OFFSET]; + *data4 = *((short int *)(&CurrDev->data_in[COUNTER_1_OFFSET])); + *data5 = *((short int *)(&CurrDev->data_in[COUNTER_2_OFFSET])); + return 0; + } + else + return K8055_ERROR; +} + +int SetAllValues(int DigitalData, int AdData1, int AdData2) +{ + CurrDev->data_out[1] = (unsigned char)DigitalData; + CurrDev->data_out[2] = (unsigned char)AdData1; + CurrDev->data_out[3] = (unsigned char)AdData2; + + return WriteK8055Data(CMD_SET_ANALOG_DIGITAL); +} + +int ResetCounter(long CounterNo) +{ + if (CounterNo == 1 || CounterNo == 2) + { + CurrDev->data_out[0] = 0x02 + (unsigned char)CounterNo; /* counter selection */ + CurrDev->data_out[3 + CounterNo] = 0x00; + return WriteK8055Data(CurrDev->data_out[0]); + } + else + return K8055_ERROR; +} + +long ReadCounter(long CounterNo) +{ + if (CounterNo == 1 || CounterNo == 2) + { + if (ReadK8055Data() == 0) + { + if (CounterNo == 2) + return *((short int *)(&CurrDev->data_in[COUNTER_2_OFFSET])); + else + return *((short int *)(&CurrDev->data_in[COUNTER_1_OFFSET])); + } + else + return K8055_ERROR; + } + else + return K8055_ERROR; +} + +int SetCounterDebounceTime(long CounterNo, long DebounceTime) +{ + float value; + + if (CounterNo == 1 || CounterNo == 2) + { + CurrDev->data_out[0] = (unsigned char)CounterNo; + /* the velleman k8055 use a exponetial formula to split up the + DebounceTime 0-7450 over value 1-255. I've tested every value and + found that the formula dbt=0,338*value^1,8017 is closest to + vellemans dll. By testing and measuring times on the other hand I + found the formula dbt=0,115*x^2 quite near the actual values, a + little below at really low values and a little above at really + high values. But the time set with this formula is within +-4% */ + if (DebounceTime > 7450) + DebounceTime = 7450; + value = sqrtf(DebounceTime / 0.115); + if (value > ((int)value + 0.49999999)) /* simple round() function) */ + value += 1; + CurrDev->data_out[5 + CounterNo] = (unsigned char)value; + if (DEBUG) + fprintf(stderr, "Debouncetime%d value for k8055:%d\n", + (int)CounterNo, CurrDev->data_out[5 + CounterNo]); + return WriteK8055Data(CurrDev->data_out[0]); + } + else + return K8055_ERROR; +} + +char * Version(void) +{ + return(VERSION); +} @@ -0,0 +1,295 @@ +/* $Id: main.c,v 1.3 2007/03/15 14:37:58 pjetur Exp $ + *************************************************************************** + * Copyright (C) 2004 by Nicolas Sutre * + * nicolas.sutre@free.fr * + * * + * Copyright (C) 2005 by Bob Dempsey * + * bdempsey_64@msn.com * + * * + * Copyright (C) 2005 by Julien Etelain and Edward Nys * + * Converted to C * + * Commented and improved by Julien Etelain <julien.etelain@utbm.fr> * + * Edward Nys <edward.ny@utbm.fr> * + * * + * Copyleft (L) 2005 by Sven Lindberg * + * k8055@k8055.mine.nu * + * Give it up already :) Simplified (read improved..) and included * + * with k8055 lib and with a functional man page * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 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. * + ***************************************************************************/ + +#include <string.h> +#include <stdio.h> +#include <usb.h> +#include <assert.h> +#include <sys/time.h> +#include "k8055.h" + +#define STR_BUFF 256 +#define false 0 +#define true 1 + +extern int DEBUG; + +int ia1 = -1; +int ia2 = -1; +int id8 = -1; +int ipid = 0; + +int numread = 1; + +int debug = 0; + +int dbt1 = -1; // (-1 => not to set) +int dbt2 = -1; // (-1 => not to set) + +int resetcnt1 = false; +int resetcnt2 = false; + +int delay = 0; + +/* + Convert a string on n chars to an integer + Return 1 on sucess + 0 on failure (non number) +*/ +int Convert_StringToInt(char *text, int *i) +{ + return sscanf(text, "%d", i); +} + +/* + Write help to standard output +*/ +void display_help ( char *params[] ) { + + printf("K8055 version %s MrBrain Build\n",Version()); + printf("Copyright (C) 2004 by Nicolas Sutre\n"); + printf("Copyright (C) 2005 by Bob Dempsey\n"); + printf("Copyright (C) 2005 by Julien Etelain and Edward Nys\n"); + printf("Copyleft (L) 2005 by Sven Lindberg\n"); + printf("\n"); + printf("Syntax : %s [-p:(number)] [-d:(value)] [-a1:(value)] [-a2:(value)]\n",params[0]); + printf(" [-num:(number) [-delay:(number)] [-dbt1:(value)]\n"); + printf(" [-dbt2:(value)] [-reset1] [-reset2] [-debug]\n"); + printf(" -p:(number) Set board number\n"); + printf(" -d:(value) Set digital output value (8 bits in decimal)\n"); + printf(" -a1:(value) Set analog output 1 value (0-255)\n"); + printf(" -a2:(value) Set analog output 2 value (0-255)\n"); + printf(" -num:(number) Set number of measures\n"); + printf(" -delay:(number) Set delay between two measure (in msec)\n"); + printf(" -dbt1:(value) Set debounce time for counter 1 (in msec)\n"); + printf(" -dbt2:(value) Set debounce time for counter 2 (in msec)\n"); + printf(" -reset1 Reset counter 1\n"); + printf(" -reset2 Reset counter 2\n"); + printf(" -debug Activate debug mode\n"); + printf("Example : %s -p:1 -d:147 -a1:25 -a2:203\n",params[0]); + printf("\n"); + printf("Output : (timestamp);(digital);(analog 1);(analog 2);(counter 1);(counter 2)\n"); + printf("Note : timestamp is the number of msec when data is read since program start\n"); + printf("Example : 499;16;128;230;9;8\n"); + printf("499 : Measure done 499 msec after program start\n"); + +} + + +/* + Read arguments, and store values + Return true if arguments are valid + else return false +*/ +int read_param(int argc,char *params[]) +{ + int erreurParam = false; + int i; + + ipid = 0; + + for (i=1; i<argc;i++) + { + if ( !strncmp(params[i],"-p:",3) && + !Convert_StringToInt(params[i]+3,&ipid) ) erreurParam = true; + else + if ( !strncmp(params[i],"-a1:",4) && + !Convert_StringToInt(params[i]+4,&ia1) ) erreurParam = true; + else + if ( !strncmp(params[i],"-a2:",4) && + !Convert_StringToInt(params[i]+4,&ia2) ) erreurParam = true; + else + if ( !strncmp(params[i],"-d:",3) && + !Convert_StringToInt(params[i]+3,&id8) ) erreurParam = true; + else + if ( !strncmp(params[i],"-num:",5) && + !Convert_StringToInt(params[i]+5,&numread) ) erreurParam = true; + else + if ( !strncmp(params[i],"-delay:",7) && + !Convert_StringToInt(params[i]+7,&delay) ) erreurParam = true; + else + if ( !strncmp(params[i],"-dbt1:",6) && + !Convert_StringToInt(params[i]+6,&dbt1) ) erreurParam = true; + else + if ( !strncmp(params[i],"-dbt2:",6) && + !Convert_StringToInt(params[i]+6,&dbt2) ) erreurParam = true; + else + if ( !strcmp(params[i],"-debug") ){ + debug = true; + DEBUG = true; + } + else + if ( !strcmp(params[i],"-reset1") ) resetcnt1 = true; + else + if ( !strcmp(params[i],"-reset2") ) resetcnt2 = true; + else + if ( !strcmp(params[i],"--help") ) { + display_help(params); + return false; + } + + } + + + /* + Send parameters to standart error + */ + if ( debug ) + fprintf(stderr,"Parameters : Card=%d Analog1=%d Analog2=%d Digital=%d\n",ipid,ia1,ia2,id8); + + if (ipid<0 || ipid>3){ + printf("Invalid board address!\n"); + return -1; + } + + + if (erreurParam) + { + + printf("Invalid or incomplete options\n"); + + display_help(params); + return false; + } + + + return true; +} + +/* + Give current timestamp in miliseconds +*/ +inline unsigned long int time_msec ( void ) { + struct timeval t; struct timezone tz; + gettimeofday (&t,&tz); + return (1000*t.tv_sec)+(t.tv_usec/1000); +} + + +int main (int argc,char *params[]) +{ + int i,result; + long d=0; + long a1=0,a2=0; + long c1=0, c2=0; + unsigned long int start,mstart=0,lastcall=0; + + start = time_msec(); + + /* + Load parameters + If parameters are valid continue + */ + + if (read_param(argc,params)) + { + /* + Initialise USB system + and enable debug mode + + if ( debug ) + usb_set_debug(2); + */ + /* + Search the device + */ + if ( OpenDevice(ipid)<0 ) { + printf("Could not open the k8055 (port:%d)\nPlease ensure that the device is correctly connected.\n",ipid); + return (-1); + + } else { + + if ( resetcnt1 ) + ResetCounter(1); + if ( resetcnt2 ) + ResetCounter(2); + if ( dbt1 != -1 ) + SetCounterDebounceTime(1,dbt1); + if ( dbt2 != -1 ) + SetCounterDebounceTime(2,dbt1); + + if ((ia1!=-1) && (ia2!=-1) && (id8!=-1)) { + result = SetAllValues(id8,ia1,ia2); + if (debug) printf("SetAllValues=%d - Digital:%d, analog1:%d, analog2:%d\n",result,id8,ia1,ia2); + } + else if ((id8 != -1) && (ia1!=-1)) { + result = SetAllValues(id8,ia1,0); + if (debug) printf("SetAllValues=%d - Digital:%d, analog1:%d\n",result,id8,ia1); + } + else if ((id8 != -1) && (ia2!=-1)) { + result = SetAllValues(id8,0,ia2); + if (debug) printf("SetAllValues=%d - Digital:%d, analog2:%d\n",result,id8,ia2); + } + else if ((ia1 != -1) && (ia2!=-1)) { + result = SetAllValues(0,ia1,ia2); + if (debug) printf("SetAllValues=%d - analog1:%d, analog2:%d\n",result,ia1,ia2); + } + else { + if (ia1!=-1) { + result=OutputAnalogChannel(1,ia1); + if (debug) printf("Set analog1:%d=>%d\n",ia1,result); + } + if (ia2!=-1) { + result=OutputAnalogChannel(2,ia2); + if (debug) printf("Set analog2:%d=>%d\n",ia2,result); + } + if (id8!=-1) { + result=WriteAllDigital((long)id8); + if (debug) printf("Set digital:%d=>%d\n",id8,result); + } + } + + mstart = time_msec(); // Measure start + for (i=0; i<numread; i++) { + + if ( delay ) { + // Wait until next measure + while ( time_msec()-mstart < i*delay ); + } + ReadAllValues( &d,&a1,&a2,&c1,&c2); + +/* ReadAllAnalog(&a1,&a2); + d=ReadAllDigital(); + c1=ReadCounter(1); + c2=ReadCounter(2); +*/ + lastcall = time_msec(); + printf("%d;%d;%d;%d;%d;%d\n", (int)(lastcall-start),(int)d, (int)a1, (int)a2,(int)c1,(int)c2 ); + } + + CloseDevice(); + } + } + return 0; +} diff --git a/man/k8055.1.gz b/man/k8055.1.gz Binary files differnew file mode 100644 index 0000000..042fdf4 --- /dev/null +++ b/man/k8055.1.gz diff --git a/pyk8055/Makefile b/pyk8055/Makefile new file mode 100644 index 0000000..a2069d3 --- /dev/null +++ b/pyk8055/Makefile @@ -0,0 +1,37 @@ +# $Id: Makefile,v 1.3 2007/04/08 10:54:49 pjetur Exp $ +# +#cc = gcc +#pylibdir = pyk8055 +#libs = -lusb -L/usr/lib -lm + +# We have to build extension "inplace" if We're to +# run samples locally without installing + +all: libk8055.i ../libk8055.c + python setup.py build_ext --inplace + python setup.py build + +# Or in plain language +# swig -python libk8055.i +# cc -fpic -O2 -c ../libk8055.c -o ./libk8055.o +# cc -fpic -O2 -c libk8055_wrap.c -I /usr/include/python2.4/ -o libk8055_wrap.o +# ld -shared libk8055.o libk8055_wrap.o -lusb -o _pyk8055.so +## mv -f pyk8055.py __init__.py + +.PHONY: kdemo + +kdemo: k8055qt.py frmk8055qt.ui frmk8055qt.ui.h + pyuic frmk8055qt.ui -o frmk8055qt.py + +# install will both make build and install +install: + python setup.py install + +# Remove all swig generated files +clean: + python setup.py clean --all + rm -f *.o _pyk8055.so libk8055_wrap.c pyk8055.py pyk8055.pyc + +uninstall: + python setup.py uninstall + #rm -f /usr/lib/python-2.4/site-packages/pyk8055.py /usr/lib/python-2.4/site-packages/_pyk8055.so diff --git a/pyk8055/frmk8055qt.ui b/pyk8055/frmk8055qt.ui new file mode 100644 index 0000000..2669c01 --- /dev/null +++ b/pyk8055/frmk8055qt.ui @@ -0,0 +1,1422 @@ +<!DOCTYPE UI><UI version="3.3" stdsetdef="1"> +<class>K8055QT</class> +<comment>Python:#from kdecore import * +Python:from kdeui import * +Python:from pyk8055 import * +</comment> +<widget class="QDialog"> + <property name="name"> + <cstring>K8055QT</cstring> + </property> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>600</width> + <height>314</height> + </rect> + </property> + <property name="caption"> + <string>K8055 Status</string> + </property> + <widget class="QButtonGroup"> + <property name="name"> + <cstring>OutputGroup</cstring> + </property> + <property name="geometry"> + <rect> + <x>320</x> + <y>70</y> + <width>270</width> + <height>51</height> + </rect> + </property> + <property name="title"> + <string>Digital Output</string> + </property> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox5</cstring> + </property> + <property name="geometry"> + <rect> + <x>140</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>5</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 5</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox6</cstring> + </property> + <property name="geometry"> + <rect> + <x>169</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>6</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 6</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox7</cstring> + </property> + <property name="geometry"> + <rect> + <x>199</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>7</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 7</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox8</cstring> + </property> + <property name="geometry"> + <rect> + <x>229</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>8</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 8</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox1</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>1</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 1</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox2</cstring> + </property> + <property name="geometry"> + <rect> + <x>42</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>2</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 2</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox3</cstring> + </property> + <property name="geometry"> + <rect> + <x>76</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>3</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 3</string> + </property> + </widget> + <widget class="QCheckBox"> + <property name="name"> + <cstring>OutputBox4</cstring> + </property> + <property name="geometry"> + <rect> + <x>110</x> + <y>20</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>4</string> + </property> + <property name="toolTip" stdset="0"> + <string>Digital Output 4</string> + </property> + </widget> + </widget> + <widget class="QButtonGroup"> + <property name="name"> + <cstring>InputGroup</cstring> + </property> + <property name="geometry"> + <rect> + <x>320</x> + <y>130</y> + <width>270</width> + <height>70</height> + </rect> + </property> + <property name="title"> + <string>Digital Input</string> + </property> + <widget class="QLabel"> + <property name="name"> + <cstring>DigitaltextLabel1</cstring> + </property> + <property name="geometry"> + <rect> + <x>18</x> + <y>40</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="text"> + <string>1</string> + </property> + <property name="alignment"> + <set>AlignCenter</set> + </property> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>DigitaltextLabel4</cstring> + </property> + <property name="geometry"> + <rect> + <x>170</x> + <y>40</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="text"> + <string>4</string> + </property> + <property name="alignment"> + <set>AlignCenter</set> + </property> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>DigitaltextLabel5</cstring> + </property> + <property name="geometry"> + <rect> + <x>220</x> + <y>40</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="text"> + <string>5</string> + </property> + <property name="alignment"> + <set>AlignCenter</set> + </property> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>DigitaltextLabel2</cstring> + </property> + <property name="geometry"> + <rect> + <x>69</x> + <y>40</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="text"> + <string>2</string> + </property> + <property name="alignment"> + <set>AlignCenter</set> + </property> + </widget> + <widget class="QLabel"> + <property name="name"> + <cstring>DigitaltextLabel3</cstring> + </property> + <property name="geometry"> + <rect> + <x>120</x> + <y>40</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="text"> + <string>3</string> + </property> + <property name="alignment"> + <set>AlignCenter</set> + </property> + </widget> + <widget class="KLed"> + <property name="name"> + <cstring>DigitalLed1</cstring> + </property> + <property name="geometry"> + <rect> + <x>20</x> + <y>20</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="state"> + <enum>Off</enum> + </property> + <property name="color"> + <color> + <red>255</red> + <green>0</green> + <blue>0</blue> + </color> + </property> + <property name="toolTip" stdset="0"> + <string>Digital 1 input state</string> + </property> + </widget> + <widget class="KLed"> + <property name="name"> + <cstring>DigitalLed2</cstring> + </property> + <property name="geometry"> + <rect> + <x>70</x> + <y>20</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="state"> + <enum>Off</enum> + </property> + <property name="color"> + <color> + <red>255</red> + <green>0</green> + <blue>0</blue> + </color> + </property> + <property name="toolTip" stdset="0"> + <string>Digital 2 input state</string> + </property> + </widget> + <widget class="KLed"> + <property name="name"> + <cstring>DigitalLed3</cstring> + </property> + <property name="geometry"> + <rect> + <x>121</x> + <y>20</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="state"> + <enum>Off</enum> + </property> + <property name="color"> + <color> + <red>255</red> + <green>0</green> + <blue>0</blue> + </color> + </property> + <property name="toolTip" stdset="0"> + <string>Digital 3 input state</string> + </property> + </widget> + <widget class="KLed"> + <property name="name"> + <cstring>DigitalLed4</cstring> + </property> + <property name="geometry"> + <rect> + <x>173</x> + <y>20</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="state"> + <enum>Off</enum> + </property> + <property name="color"> + <color> + <red>255</red> + <green>0</green> + <blue>0</blue> + </color> + </property> + <property name="toolTip" stdset="0"> + <string>Digital 4 input state</string> + </property> + </widget> + <widget class="KLed"> + <property name="name"> + <cstring>DigitalLed5</cstring> + </property> + <property name="geometry"> + <rect> + <x>221</x> + <y>20</y> + <width>20</width> + <height>20</height> + </rect> + </property> + <property name="state"> + <enum>Off</enum> + </property> + <property name="color"> + <color> + <red>255</red> + <green>0</green> + <blue>0</blue> + </color> + </property> + <property name="toolTip" stdset="0"> + <string>Digital 5 input state</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupCounter1</cstring> + </property> + <property name="geometry"> + <rect> + <x>320</x> + <y>200</y> + <width>271</width> + <height>51</height> + </rect> + </property> + <property name="title"> + <string>Counter 1</string> + </property> + <widget class="QComboBox"> + <item> + <property name="text"> + <string>1 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>2 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>5 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>10 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>50 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>100 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>500 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>1000 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>2000 ms</string> + </property> + </item> + <property name="name"> + <cstring>comboCounter1</cstring> + </property> + <property name="geometry"> + <rect> + <x>171</x> + <y>20</y> + <width>90</width> + <height>21</height> + </rect> + </property> + <property name="toolTip" stdset="0"> + <string>Debounce value counter #1</string> + </property> + </widget> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>Counter1Value</cstring> + </property> + <property name="geometry"> + <rect> + <x>20</x> + <y>20</y> + <width>71</width> + <height>21</height> + </rect> + </property> + <property name="frameShadow"> + <enum>Plain</enum> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Counter #1</string> + </property> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>ClearCounter1</cstring> + </property> + <property name="geometry"> + <rect> + <x>100</x> + <y>20</y> + <width>60</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>Reset</string> + </property> + <property name="toolTip" stdset="0"> + <string>Reset Counter #1</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupCounter2</cstring> + </property> + <property name="geometry"> + <rect> + <x>320</x> + <y>250</y> + <width>271</width> + <height>51</height> + </rect> + </property> + <property name="title"> + <string>Counter 2</string> + </property> + <widget class="QComboBox"> + <item> + <property name="text"> + <string>1 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>2 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>5 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>10 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>50 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>100 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>500 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>1000 ms</string> + </property> + </item> + <item> + <property name="text"> + <string>2000 ms</string> + </property> + </item> + <property name="name"> + <cstring>comboCounter2</cstring> + </property> + <property name="geometry"> + <rect> + <x>171</x> + <y>20</y> + <width>90</width> + <height>21</height> + </rect> + </property> + <property name="toolTip" stdset="0"> + <string>Debounce value counter #2</string> + </property> + </widget> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>Counter2Value</cstring> + </property> + <property name="geometry"> + <rect> + <x>20</x> + <y>20</y> + <width>71</width> + <height>21</height> + </rect> + </property> + <property name="frameShadow"> + <enum>Plain</enum> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Counter #2</string> + </property> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>ClearCounter2</cstring> + </property> + <property name="geometry"> + <rect> + <x>100</x> + <y>20</y> + <width>60</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>Reset</string> + </property> + <property name="toolTip" stdset="0"> + <string>Reset Counter #2</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupDigitalButtonBox</cstring> + </property> + <property name="geometry"> + <rect> + <x>200</x> + <y>10</y> + <width>110</width> + <height>90</height> + </rect> + </property> + <property name="title"> + <string>Digital</string> + </property> + <widget class="QPushButton"> + <property name="name"> + <cstring>ClearAllDigitalButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>50</y> + <width>90</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Clear All</string> + </property> + <property name="toolTip" stdset="0"> + <string>Clear all digital outputs</string> + </property> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>SetAllDigitalButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>20</y> + <width>90</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Set All</string> + </property> + <property name="toolTip" stdset="0"> + <string>Set all digital outputs</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupAnalogButtonBox</cstring> + </property> + <property name="geometry"> + <rect> + <x>200</x> + <y>110</y> + <width>110</width> + <height>90</height> + </rect> + </property> + <property name="title"> + <string>Analog</string> + </property> + <widget class="QPushButton"> + <property name="name"> + <cstring>ClearAllAnalogButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>50</y> + <width>90</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Clear All</string> + </property> + <property name="toolTip" stdset="0"> + <string>Set all analog outputs low</string> + </property> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>SetAllAnalogButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>20</y> + <width>90</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Set All</string> + </property> + <property name="toolTip" stdset="0"> + <string>Set all analog outputs high</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupTestButtonBox</cstring> + </property> + <property name="geometry"> + <rect> + <x>200</x> + <y>210</y> + <width>110</width> + <height>90</height> + </rect> + </property> + <property name="title"> + <string>Test</string> + </property> + <widget class="QPushButton"> + <property name="name"> + <cstring>TestAnalogButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>50</y> + <width>90</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Analog</string> + </property> + <property name="toolTip" stdset="0"> + <string>Run analog tests</string> + </property> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>TestDigitalButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>20</y> + <width>90</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Digital</string> + </property> + <property name="toolTip" stdset="0"> + <string>Run digital output tests</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupBoxAD2</cstring> + </property> + <property name="geometry"> + <rect> + <x>140</x> + <y>10</y> + <width>45</width> + <height>290</height> + </rect> + </property> + <property name="title"> + <string>AD2</string> + </property> + <widget class="QScrollBar"> + <property name="name"> + <cstring>BarAD2</cstring> + </property> + <property name="geometry"> + <rect> + <x>16</x> + <y>20</y> + <width>20</width> + <height>230</height> + </rect> + </property> + <property name="maxValue"> + <number>255</number> + </property> + <property name="pageStep"> + <number>1</number> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog input value - AD2</string> + </property> + </widget> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>AD2Value</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>260</y> + <width>30</width> + <height>20</height> + </rect> + </property> + <property name="frameShape"> + <enum>NoFrame</enum> + </property> + <property name="numDigits"> + <number>3</number> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog value AD2</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupBoxAD1</cstring> + </property> + <property name="geometry"> + <rect> + <x>100</x> + <y>10</y> + <width>45</width> + <height>290</height> + </rect> + </property> + <property name="title"> + <string>AD1</string> + </property> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>AD1Value</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>260</y> + <width>30</width> + <height>20</height> + </rect> + </property> + <property name="frameShape"> + <enum>NoFrame</enum> + </property> + <property name="numDigits"> + <number>3</number> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog value AD1</string> + </property> + </widget> + <widget class="QScrollBar"> + <property name="name"> + <cstring>BarAD1</cstring> + </property> + <property name="geometry"> + <rect> + <x>15</x> + <y>20</y> + <width>20</width> + <height>230</height> + </rect> + </property> + <property name="maxValue"> + <number>255</number> + </property> + <property name="pageStep"> + <number>1</number> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog input value - AD1</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupBoxDA2</cstring> + </property> + <property name="geometry"> + <rect> + <x>55</x> + <y>10</y> + <width>45</width> + <height>290</height> + </rect> + </property> + <property name="title"> + <string>DA2</string> + </property> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>DA2Value</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>260</y> + <width>30</width> + <height>20</height> + </rect> + </property> + <property name="frameShape"> + <enum>NoFrame</enum> + </property> + <property name="numDigits"> + <number>3</number> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog value DA2</string> + </property> + </widget> + <widget class="QScrollBar"> + <property name="name"> + <cstring>BarDA2</cstring> + </property> + <property name="geometry"> + <rect> + <x>15</x> + <y>20</y> + <width>20</width> + <height>230</height> + </rect> + </property> + <property name="maxValue"> + <number>255</number> + </property> + <property name="pageStep"> + <number>1</number> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog output value - DA2</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupBoxDA1</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>10</y> + <width>45</width> + <height>290</height> + </rect> + </property> + <property name="title"> + <string>DA1</string> + </property> + <widget class="QLCDNumber"> + <property name="name"> + <cstring>DA1Value</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>260</y> + <width>30</width> + <height>20</height> + </rect> + </property> + <property name="frameShape"> + <enum>NoFrame</enum> + </property> + <property name="numDigits"> + <number>3</number> + </property> + <property name="segmentStyle"> + <enum>Flat</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog value DA1</string> + </property> + </widget> + <widget class="QScrollBar"> + <property name="name"> + <cstring>BarDA1</cstring> + </property> + <property name="geometry"> + <rect> + <x>15</x> + <y>20</y> + <width>20</width> + <height>230</height> + </rect> + </property> + <property name="maxValue"> + <number>255</number> + </property> + <property name="pageStep"> + <number>1</number> + </property> + <property name="orientation"> + <enum>Vertical</enum> + </property> + <property name="toolTip" stdset="0"> + <string>Analog output value - DA1</string> + </property> + </widget> + </widget> + <widget class="QGroupBox"> + <property name="name"> + <cstring>groupCard</cstring> + </property> + <property name="geometry"> + <rect> + <x>320</x> + <y>10</y> + <width>271</width> + <height>51</height> + </rect> + </property> + <property name="title"> + <string>Card</string> + </property> + <widget class="QButtonGroup"> + <property name="name"> + <cstring>CardRadioGroup</cstring> + </property> + <property name="geometry"> + <rect> + <x>10</x> + <y>19</y> + <width>151</width> + <height>20</height> + </rect> + </property> + <property name="frameShape"> + <enum>NoFrame</enum> + </property> + <property name="title"> + <string></string> + </property> + <widget class="QRadioButton"> + <property name="name"> + <cstring>CardButton1</cstring> + </property> + <property name="geometry"> + <rect> + <x>0</x> + <y>0</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>1</string> + </property> + <property name="checked"> + <bool>true</bool> + </property> + <property name="toolTip" stdset="0"> + <string>Select Card #1</string> + </property> + </widget> + <widget class="QRadioButton"> + <property name="name"> + <cstring>CardButton3</cstring> + </property> + <property name="geometry"> + <rect> + <x>80</x> + <y>0</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>3</string> + </property> + <property name="toolTip" stdset="0"> + <string>Select Card #3</string> + </property> + </widget> + <widget class="QRadioButton"> + <property name="name"> + <cstring>CardButton2</cstring> + </property> + <property name="geometry"> + <rect> + <x>40</x> + <y>0</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>2</string> + </property> + <property name="toolTip" stdset="0"> + <string>Select Card #2</string> + </property> + </widget> + <widget class="QRadioButton"> + <property name="name"> + <cstring>CardButton4</cstring> + </property> + <property name="geometry"> + <rect> + <x>120</x> + <y>0</y> + <width>30</width> + <height>21</height> + </rect> + </property> + <property name="text"> + <string>4</string> + </property> + <property name="toolTip" stdset="0"> + <string>Select Card #4</string> + </property> + </widget> + </widget> + <widget class="QPushButton"> + <property name="name"> + <cstring>ConnectButton</cstring> + </property> + <property name="geometry"> + <rect> + <x>179</x> + <y>15</y> + <width>80</width> + <height>30</height> + </rect> + </property> + <property name="text"> + <string>Connect</string> + </property> + <property name="toolTip" stdset="0"> + <string>Connect to selected card</string> + </property> + </widget> + </widget> +</widget> +<connections> + <connection> + <sender>ConnectButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>ConnectButton_clicked()</slot> + </connection> + <connection> + <sender>CardButton1</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>CardButton1_clicked()</slot> + </connection> + <connection> + <sender>CardButton2</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>CardButton2_clicked()</slot> + </connection> + <connection> + <sender>ClearCounter2</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>ClearCounter2_clicked()</slot> + </connection> + <connection> + <sender>OutputBox1</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox1_clicked()</slot> + </connection> + <connection> + <sender>ClearCounter1</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>ClearCounter1_clicked()</slot> + </connection> + <connection> + <sender>OutputBox8</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox8_clicked()</slot> + </connection> + <connection> + <sender>OutputBox7</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox7_clicked()</slot> + </connection> + <connection> + <sender>OutputBox2</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox2_clicked()</slot> + </connection> + <connection> + <sender>OutputBox3</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox3_clicked()</slot> + </connection> + <connection> + <sender>OutputBox4</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox4_clicked()</slot> + </connection> + <connection> + <sender>OutputBox5</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox5_clicked()</slot> + </connection> + <connection> + <sender>OutputBox6</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>OutputBox6_clicked()</slot> + </connection> + <connection> + <sender>SetAllAnalogButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>SetAllAnalogButton_clicked()</slot> + </connection> + <connection> + <sender>ClearAllAnalogButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>ClearAllAnalogButton_clicked()</slot> + </connection> + <connection> + <sender>SetAllDigitalButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>SetAllDigitalButton_clicked()</slot> + </connection> + <connection> + <sender>ClearAllDigitalButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>ClearAllDigitalButton_clicked()</slot> + </connection> + <connection> + <sender>BarAD2</sender> + <signal>valueChanged(int)</signal> + <receiver>K8055QT</receiver> + <slot>BarAD2_valueChanged(int)</slot> + </connection> + <connection> + <sender>BarAD1</sender> + <signal>valueChanged(int)</signal> + <receiver>K8055QT</receiver> + <slot>BarAD1_valueChanged(int)</slot> + </connection> + <connection> + <sender>comboCounter2</sender> + <signal>activated(int)</signal> + <receiver>K8055QT</receiver> + <slot>comboCounter2_activated(int)</slot> + </connection> + <connection> + <sender>comboCounter1</sender> + <signal>activated(int)</signal> + <receiver>K8055QT</receiver> + <slot>comboCounter1_activated(int)</slot> + </connection> + <connection> + <sender>TestDigitalButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>TestDigitalButton_clicked()</slot> + </connection> + <connection> + <sender>TestAnalogButton</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>TestAnalogButton_clicked()</slot> + </connection> + <connection> + <sender>CardButton3</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>CardButton3_clicked()</slot> + </connection> + <connection> + <sender>CardButton4</sender> + <signal>clicked()</signal> + <receiver>K8055QT</receiver> + <slot>CardButton4_clicked()</slot> + </connection> +</connections> +<includes> + <include location="local" impldecl="in implementation">frmk8055qt.ui.h</include> +</includes> +<variables> + <variable access="private">Kpriv;</variable> + <variable access="public">Kp = False;</variable> +</variables> +<slots> + <slot>ConnectButton_clicked()</slot> + <slot>CardButton1_clicked()</slot> + <slot>CardButton2_clicked()</slot> + <slot>CardButton3_clicked()</slot> + <slot>CardButton4_clicked()</slot> + <slot>init()</slot> + <slot>ClearCounter1_clicked()</slot> + <slot>ClearCounter2_clicked()</slot> + <slot>OutputBox1_clicked()</slot> + <slot>OutputBox2_clicked()</slot> + <slot>OutputBox3_clicked()</slot> + <slot>OutputBox4_clicked()</slot> + <slot>OutputBox5_clicked()</slot> + <slot>OutputBox6_clicked()</slot> + <slot>OutputBox7_clicked()</slot> + <slot>OutputBox8_clicked()</slot> + <slot>SetAllAnalogButton_clicked()</slot> + <slot>ClearAllAnalogButton_clicked()</slot> + <slot>SetAllDigitalButton_clicked()</slot> + <slot>ClearAllDigitalButton_clicked()</slot> + <slot>BarAD1_valueChanged( int )</slot> + <slot>BarAD2_valueChanged( int )</slot> + <slot>comboCounter2_activated( int )</slot> + <slot>comboCounter1_activated( int )</slot> + <slot>TestDigitalButton_clicked()</slot> + <slot>TestAnalogButton_clicked()</slot> +</slots> +<layoutdefaults spacing="6" margin="11"/> +<includehints> + <includehint>kled.h</includehint> + <includehint>kled.h</includehint> + <includehint>kled.h</includehint> + <includehint>kled.h</includehint> + <includehint>kled.h</includehint> +</includehints> +</UI> diff --git a/pyk8055/frmk8055qt.ui.h b/pyk8055/frmk8055qt.ui.h new file mode 100644 index 0000000..1e986e6 --- /dev/null +++ b/pyk8055/frmk8055qt.ui.h @@ -0,0 +1,260 @@ +/**************************************************************************** +** ui.h extension file, included from the uic-generated form implementation. +** +** If you want to add, delete, or rename functions or slots, use +** Qt Designer to update this file, preserving your code. +** +** You should not define a constructor or destructor in this file. +** Instead, write your code in functions called init() and destroy(). +** These will automatically be called by the form's constructor and +** destructor. +*****************************************************************************/ + + +void K8055QT::ConnectButton_clicked() +{ + if (self.card != None) and (self.k == None): + try: + #print "Connect to card #",self.card + self.k = k8055(self.card) + self.EnableAll() + self.ClearAllDigitalButton_clicked() + self.ClearAllAnalogButton_clicked() + self.comboCounter1.setCurrentItem(0) + self.comboCounter2.setCurrentItem(0) + + self.ConnectButton.setText(self.__tr("Disconnect")) + except: + print "No such Card" + elif (self.k != None): + try: + #print "Disconnect from card #",self.card + self.k.CloseDevice() + self.k = None + self.DisableAll() + self.OutputBox1.setChecked(0) + self.OutputBox2.setChecked(0) + self.OutputBox3.setChecked(0) + self.OutputBox4.setChecked(0) + self.OutputBox5.setChecked(0) + self.OutputBox6.setChecked(0) + self.OutputBox7.setChecked(0) + self.OutputBox8.setChecked(0) + self.BarDA1.setValue(0) + self.BarDA2.setValue(0) + self.BarAD1.setValue(0) + self.BarAD2.setValue(0) + self.DA1Value.setProperty("intValue",QVariant(0)) + self.DA2Value.setProperty("intValue",QVariant(0)) + self.AD1Value.setProperty("intValue",QVariant(0)) + self.AD2Value.setProperty("intValue",QVariant(0)) + self.comboCounter1.setCurrentItem(0) + self.comboCounter2.setCurrentItem(0) + self.Counter1Value.setProperty("intValue",QVariant(0)) + self.Counter2Value.setProperty("intValue",QVariant(0)) + self.ConnectButton.setText(self.__tr("Connect")) + except: + pass + +} + + +void K8055QT::CardButton1_clicked() +{ + self.card = 0 +} + +void K8055QT::CardButton2_clicked() +{ + self.card = 1 +} + +void K8055QT::CardButton3_clicked() +{ + self.card = 2 +} + +void K8055QT::CardButton4_clicked() +{ + self.card = 3 +} + + +void K8055QT::init() +{ + self.k = None + self.DisableAll() +} + +void K8055QT::ClearCounter1_clicked() +{ + if self.k: + self.k.ResetCounter(1) +} + +void K8055QT::ClearCounter2_clicked() +{ + if self.k: + self.k.ResetCounter(2) +} + + +void K8055QT::OutputBox1_clicked() +{ + if self.k: + if self.OutputBox1.isChecked(): + self.k.SetDigitalChannel(1) + else: + self.k.ClearDigitalChannel(1) +} + +void K8055QT::OutputBox2_clicked() +{ + if self.k: + if self.OutputBox2.isChecked(): + self.k.SetDigitalChannel(2) + else: + self.k.ClearDigitalChannel(2) + +void K8055QT::OutputBox3_clicked() +{ + if self.k: + if self.OutputBox3.isChecked(): + self.k.SetDigitalChannel(3) + else: + self.k.ClearDigitalChannel(3) +} +void K8055QT::OutputBox4_clicked() +{ + if self.k: + if self.OutputBox4.isChecked(): + self.k.SetDigitalChannel(4) + else: + self.k.ClearDigitalChannel(4) +} +void K8055QT::OutputBox5_clicked() +{ + if self.k: + if self.OutputBox5.isChecked(): + self.k.SetDigitalChannel(5) + else: + self.k.ClearDigitalChannel(5) +} +void K8055QT::OutputBox6_clicked() +{ + if self.k: + if self.OutputBox6.isChecked(): + self.k.SetDigitalChannel(6) + else: + self.k.ClearDigitalChannel(6) +} +void K8055QT::OutputBox7_clicked() +{ + if self.k: + if self.OutputBox7.isChecked(): + self.k.SetDigitalChannel(7) + else: + self.k.ClearDigitalChannel(7) +} +void K8055QT::OutputBox8_clicked() +{ + if self.k: + if self.OutputBox8.isChecked(): + self.k.SetDigitalChannel(8) + else: + self.k.ClearDigitalChannel(8) +} + + +void K8055QT::SetAllAnalogButton_clicked() +{ + if self.k: + self.k.SetAllAnalog() + self.BarAD1.setValue(0) + self.BarAD2.setValue(0) + self.AD1Value.setProperty("intValue",QVariant(255)) + self.AD2Value.setProperty("intValue",QVariant(255)) +} + + +void K8055QT::ClearAllAnalogButton_clicked() +{ + if self.k: + self.k.ClearAllAnalog() + self.BarAD1.setValue(255) + self.BarAD2.setValue(255) + self.AD1Value.setProperty("intValue",QVariant(0)) + self.AD2Value.setProperty("intValue",QVariant(0)) +} + + +void K8055QT::SetAllDigitalButton_clicked() +{ + if self.k: + self.k.SetAllDigital() + self.OutputBox1.setChecked(1) + self.OutputBox2.setChecked(1) + self.OutputBox3.setChecked(1) + self.OutputBox4.setChecked(1) + self.OutputBox5.setChecked(1) + self.OutputBox6.setChecked(1) + self.OutputBox7.setChecked(1) + self.OutputBox8.setChecked(1) +} + +void K8055QT::ClearAllDigitalButton_clicked() +{ + if self.k: + self.k.ClearAllDigital() + self.OutputBox1.setChecked(0) + self.OutputBox2.setChecked(0) + self.OutputBox3.setChecked(0) + self.OutputBox4.setChecked(0) + self.OutputBox5.setChecked(0) + self.OutputBox6.setChecked(0) + self.OutputBox7.setChecked(0) + self.OutputBox8.setChecked(0) +} + + +void K8055QT::BarAD1_valueChanged( int ) +{ + if self.k: + self.k.OutputAnalogChannel(1,255-a0) + self.AD1Value.setProperty("intValue",QVariant(255-a0)) +} + +void K8055QT::BarAD2_valueChanged( int ) +{ + if self.k: + self.k.OutputAnalogChannel(2,255-a0) + self.AD2Value.setProperty("intValue",QVariant(255-a0)) +} + + +void K8055QT::comboCounter2_activated( int ) +{ + if self.k: + v = str(self.comboCounter2.currentText()).split() + self.k.SetCounterDebounceTime(2,int(v[0])) +} + + +void K8055QT::comboCounter1_activated( int ) +{ + if self.k: + v = str(self.comboCounter1.currentText()).split() + self.k.SetCounterDebounceTime(1,int(v[0])) +} + + +void K8055QT::TestDigitalButton_clicked() +{ + self.DigitalTest() +} + + +void K8055QT::TestAnalogButton_clicked() +{ + self.AnalogTest() +} diff --git a/pyk8055/k8055.py b/pyk8055/k8055.py new file mode 100755 index 0000000..3c03a10 --- /dev/null +++ b/pyk8055/k8055.py @@ -0,0 +1,117 @@ +#!/usr/bin/env python +# $Id: k8055.py,v 1.2 2007/03/15 14:50:55 pjetur Exp $ +""" +Python version of K8055 command line program + +Copyright (C) 2007 by Pjetur G. Hjaltason + +Syntax : python k8055.py [-p:(number)] [-d:(value)] [-a1:(value)] [-a2:(value)] + [-num:(number) [-delay:(number)] [-dbt1:(value)] + [-dbt2:(value)] [-reset1] [-reset2] [-debug] [-h|--help] + -p:(number) Set board number (0/1/2/3) + -d:(value) Set digital output value (bitmask, 8 bits in decimal) + -a1:(value) Set analog output 1 value (0-255) + -a2:(value) Set analog output 2 value (0-255) + -num:(number) Set number of measures (-1 for no read) + -delay:(number) Set delay between two measures (in msec) + -dbt1:(value) Set debounce time for counter 1 (in msec) + -dbt2:(value) Set debounce time for counter 2 (in msec) + -reset1 Reset counter 1 + -reset2 Reset counter 2 + -debug Activate debug mode + -h or --help Print this text + +Example : python k8055.py -p:1 -d:147 -a1:25 -a2:203 + +NOTE: + Because of the nature of commands sent to the K8055 board, this + program has no way of knowing previous state of the analog or + digial outputs, thus each run of this command will clear the previous + state - and set a new state - of the analog and digital outputs + + See header of libk8055.c for more details of K8055 commands +""" +import sys +from time import sleep, time +from pyk8055 import * + +def main(argv): + # preset values + p , db = 0,0 # Port, debug + r1, r2 = 0,0 # reset1, reset2 + dl = -1 # delay + db1,db2 = -1,-1 # debounce1, debounce2 + a1,a2,d = -1,-1,-1 # analog1, analog2, digital + nm = 1 # number of times to read, default once + + # not the standard getopts way, but... + for arg in argv: + if arg in ("-h", "--help"): + print __doc__ + sys.exit(0) + elif arg[:4] == "-a1:" : a1 = int(arg[4:]) + elif arg[:4] == "-a2:" : a2 = int(arg[4:]) + elif arg[:5] == "-num:" : nm = int(arg[5:]) + elif arg[:3] == "-d:" : d = int(arg[3:]) + elif arg[:3] == "-p:" : p = int(arg[3:]) + elif arg[:7] == "-delay:" : dl = int(arg[7:]) + elif arg[:6] == "-dbt1:" : db1 = int(arg[6:]) + elif arg[:6] == "-dbt2:" : db2 = int(arg[6:]) + elif arg == "-reset1" : r1 = 1 + elif arg == "-reset2" : r2 = 1 + elif arg == "-debug" : db = 1 + else: + print __doc__ + sys.exit(0) + + try: + # Open device + if db == 1: k = k8055(p,True) # Debug mode + else: k = k8055(p) + + # set requested + if r1 != 0: k.ResetCounter(1) + if r2 != 0: k.ResetCounter(2) + if db1 != -1: k.SetCounterDebounceTime(1, db1) + if db2 != -1: k.SetCounterDebounceTime(2, db2) + + # Try to set all digital/analog values at the same time + if (d != -1 and a1 != -1 and a2 != -1) : SetAllValues(d,a1,a2) + elif (d != -1 and a1 != -1 ) : SetAllValues(d,a1,0) + elif (d != -1 and a2 != -1 ) : SetAllValues(d,0,a2) + elif (a1 != -1 and a2 != -1 ) : SetAllValues(0,a1,a2) + # Else only one specified + else: + if d != -1: k.WriteAllDigital(d) + if a1 != -1: k.OutputAnalogChannel(1,a1) + if a2 != -1: k.OutputAnalogChannel(2,a2) + + # Now we loop (or not) for the specified number of times + # reading all the input values + + # Each read of all values will take about 2-8ms, at least + # on my setup - so no sense in using delay less than 10 + if (dl > 0) & (dl < 10): dl = 10 + + if (nm > 0) & (dl > 0): + tst = tstart = time() + i = 0 + while nm > 0: + ds = str(k) + tnow = time() + tms = (tnow - tstart) * 1000.0 + delta= dl - (tms - dl*i) + #tst = tnow + print str(int(tms+0.4999))+";"+ds + sleep((delta)/1000.0) # compensate for read time + nm -= 1 + i += 1 + elif nm > 0: + print "0;"+ str(k) + + k.CloseDevice() + + except IOError: + print "Could not open the k8055 (port:%s)" % str(p) + +main(sys.argv[1:]) diff --git a/pyk8055/k8055qt.png b/pyk8055/k8055qt.png Binary files differnew file mode 100644 index 0000000..85647db --- /dev/null +++ b/pyk8055/k8055qt.png diff --git a/pyk8055/k8055qt.py b/pyk8055/k8055qt.py new file mode 100644 index 0000000..49288f6 --- /dev/null +++ b/pyk8055/k8055qt.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# +# Python version of libK8055 demo program +# +# Copyright (C) 2007 by Pjetur G. Hjaltason +# + +import sys +from qt import * +#from qwt import * + +import time, string +from pyk8055 import * +from frmk8055qt import * + +class QTK8055(K8055QT): + def __init__(self): + K8055QT.__init__(self) + + # Not much sense in making a fancy menu yet + # + #puProg = QPopupMenu(self) + #puProg.insertItem("Quit", Kapp.quit) + + #puHelp = QPopupMenu(self) + #puHelp.insertItem("About", self.about) + + #self.menu = QMenuBar(self) + #self.menu.insertItem("Program", puProg) + #self.menu.insertItem("Help", puHelp) + + # enumerate devices + BMask = SearchDevices() + if not BMask: + print "No K8055 devices found" + exit + + # Enable those present + self.CardButton1.setEnabled((BMask & 0x01) > 0) + self.CardButton2.setEnabled((BMask & 0x02) > 0) + self.CardButton3.setEnabled((BMask & 0x04) > 0) + self.CardButton4.setEnabled((BMask & 0x08) > 0) + + # set the first one found as suggestion + if (BMask & 0x01) > 0: + self.card = 0 + self.CardButton1.setChecked(1) + elif (BMask & 0x02) > 0: + self.card = 1 + self.CardButton2.setChecked(1) + elif (BMask & 0x04) > 0: + self.card = 2 + self.CardButton3.setChecked(1) + elif (BMask & 0x08) > 0: + self.card = 3 + self.CardButton4.setChecked(1) + + self.time = QTime.currentTime() # get current time + internalTimer = QTimer( self ) # create internal timer + self.connect( internalTimer, SIGNAL("timeout()"), self.timeout ) + internalTimer.start( 100 ) # emit signal every 1/10 second + + self.timeout() + + def AnalogTest(self): + try: + for step in range(0,255,10): + self.BarAD1.setValue(step) + self.BarAD2.setValue(step) + time.sleep(0.1) + # set analog output channel 1 to 200/255*5v = 3.9V + for step in range(255,0,10): + self.BarAD1.setValue(step) + self.BarAD2.setValue(step) + time.sleep(0.1) + + # read both analog inputs + # note: this returns a list + #res = self.k.ReadAllAnalog() + #sres = res[1:] + + # There should be more interesting information in the messagebox ;-/ + + QMessageBox.information( self,'Information', "AllOK","Ok") + except: + pass + + def DigitalTest(self): + try: + # Create a rotating display of digital outputs + # while waiting for keypress on digital input 1 + # (longer than .2sec :) Loop at most 3 times + Input1High = False + for i in range(1,3): + d = 1 + self.k.WriteAllDigital(1) + while Input1High == False and d < 128: + Input1High = (self.k.ReadDigitalChannel(1) > 0) + if Input1High: break + time.sleep(0.2) # wait .2 sec + d *=2 # and continue rotating digital outputs + #if d > 128: d=1; + self.k.WriteAllDigital(d) + if Input1High: break + + res = "Digital input 1=" + str(self.k.ReadDigitalChannel(1)) + "<br>" + # read the counter on input 1 + res+= "Counter(1)=" + str(self.k.ReadCounter(1)) + "<br>" + # read the counter on input 2 + res+= "Counter(2)=" + str(self.k.ReadCounter(2)) + + # set even bits on digital outputs + self.k.WriteAllDigital(170) + time.sleep(1) + # set odd bits on digital outputs + self.k.WriteAllDigital(85) + time.sleep(1) + # Clear all digital outputs + self.k.WriteAllDigital(0) + + # There should be more interesting information in the messagebox ;-/ + + QMessageBox.information( self,'DigitalTest', res,"Ok") + except: + QMessageBox.warning( self,'DigitalTest', "Not OK","Ok") + pass + + def EnableAll(self): + self.OutputBox1.setEnabled(1) + self.OutputBox2.setEnabled(1) + self.OutputBox3.setEnabled(1) + self.OutputBox4.setEnabled(1) + self.OutputBox5.setEnabled(1) + self.OutputBox6.setEnabled(1) + self.OutputBox7.setEnabled(1) + self.OutputBox8.setEnabled(1) + self.SetAllDigitalButton.setEnabled(1) + self.ClearAllDigitalButton.setEnabled(1) + self.SetAllAnalogButton.setEnabled(1) + self.ClearAllAnalogButton.setEnabled(1) + self.comboCounter1.setEnabled(1) + self.comboCounter2.setEnabled(1) + self.ClearCounter1.setEnabled(1) + self.ClearCounter2.setEnabled(1) + self.TestDigitalButton.setEnabled(1) + self.TestAnalogButton.setEnabled(1) + self.BarAD1.setEnabled(1) + self.BarAD2.setEnabled(1) + self.BarDA1.setEnabled(1) + self.BarDA2.setEnabled(1) + + def DisableAll(self): + self.OutputBox1.setEnabled(0) + self.OutputBox2.setEnabled(0) + self.OutputBox3.setEnabled(0) + self.OutputBox4.setEnabled(0) + self.OutputBox5.setEnabled(0) + self.OutputBox6.setEnabled(0) + self.OutputBox7.setEnabled(0) + self.OutputBox8.setEnabled(0) + self.SetAllDigitalButton.setEnabled(0) + self.ClearAllDigitalButton.setEnabled(0) + self.SetAllAnalogButton.setEnabled(0) + self.ClearAllAnalogButton.setEnabled(0) + self.comboCounter1.setEnabled(0) + self.comboCounter2.setEnabled(0) + self.ClearCounter1.setEnabled(0) + self.ClearCounter2.setEnabled(0) + self.TestDigitalButton.setEnabled(0) + self.TestAnalogButton.setEnabled(0) + self.BarAD1.setEnabled(0) + self.BarAD2.setEnabled(0) + self.BarDA1.setEnabled(0) + self.BarDA2.setEnabled(0) +# +## The QTimer::timeout() signal is received by this slot. +# + + def timeout( self ): + #new_time = QTime.currentTime() # get the current time + if self.k != None: + try: + AllVal = self.k.ReadAllValues() + #print AllVal,AllVal[2] + self.BarDA1.setValue(255 - AllVal[2]) + self.BarDA2.setValue(255 - AllVal[3]) + self.DA1Value.setProperty("intValue",QVariant(AllVal[2])) + self.DA2Value.setProperty("intValue",QVariant(AllVal[3])) + self.Counter1Value.setProperty("intValue",QVariant(AllVal[4])) + self.Counter2Value.setProperty("intValue",QVariant(AllVal[5])) + + if (AllVal[1] & 0x01) > 0: + self.DigitalLed1.setState(KLed.On) + else: + self.DigitalLed1.setState(KLed.Off) + if (AllVal[1] & 0x02) > 0: + self.DigitalLed2.setState(KLed.On) + else: + self.DigitalLed2.setState(KLed.Off) + if (AllVal[1] & 0x04) > 0: + self.DigitalLed3.setState(KLed.On) + else: + self.DigitalLed3.setState(KLed.Off) + if (AllVal[1] & 0x08) > 0: + self.DigitalLed4.setState(KLed.On) + else: + self.DigitalLed4.setState(KLed.Off) + if (AllVal[1] & 0x10) > 0: + self.DigitalLed5.setState(KLed.On) + else: + self.DigitalLed5.setState(KLed.Off) + except: + print "K8055 Read failed" + + def about(self): + QMessageBox.about( self, "About k8055qt", + "k8055qt is a small GUI program using libk8055\n\n" + "Copyright 2007 Pjetur G. Hjaltason. " + "Distributed under GPL license\n\n" + "For technical support, study the source code or surf\n" + "http://sourceforge.net/projects/libk8055/\n" ) + +if __name__ == "__main__": + Kapp = QApplication(sys.argv) + QObject.connect(Kapp,SIGNAL("lastWindowClosed()"),Kapp,SLOT("quit()")) + w = QTK8055() + Kapp.setMainWidget(w) + w.show() + Kapp.exec_loop() + + diff --git a/pyk8055/k8055test.py b/pyk8055/k8055test.py new file mode 100755 index 0000000..db5ee54 --- /dev/null +++ b/pyk8055/k8055test.py @@ -0,0 +1,70 @@ +#!/usr/bin/env python +# $Id: k8055test.py,v 1.3 2007/03/28 10:09:34 pjetur Exp $ +# +# Sample pyton test program for pyk8055 wrapper +# Testing single board +# +from time import sleep +from pyk8055 import * + +try: + # CHANGE PORT HERE IF NEEDED + # Open device port 0 + k = k8055(0) + + # set analog output channel 1 to 200/255*5v = 3.9V + k.OutputAnalogChannel(1,200) + sleep(1) + # set analog output channel low again = 0V + k.OutputAnalogChannel(1,0) + + # read both analog inputs + # note: this returns a list + res = k.ReadAllAnalog() + print res[1:] + + # Test class string function + print str(k) + + # Set debounce time on counter 1 + k.SetCounterDebounceTime(1, 100) + + # reset counter 1 + k.ResetCounter(1) + + # create a rotating display of digital outputs + # while waiting for keypress on digital input 1 + # (longer than .2sec :) + Loop,dInput1,d = 0,0,1 + k.WriteAllDigital(1) + while Loop < 3 or dInput1 == 0: # is key 1 down (input 1 high) + dInput1 = k.ReadDigitalChannel(1) + Loop += 1 + sleep(0.2) # wait .2 sec + d *=2 # and continue rotating digital outputs + if d > 128: d=1; + k.WriteAllDigital(d) + + print "Digital input 1=",dInput1 + + # read the counter on input 1 + print "Counter(1)=",k.ReadCounter(1) + # read the counter on input 2 + print "Counter(2)=",k.ReadCounter(2) + + # set even bits on digital outputs + k.WriteAllDigital(170) + sleep(1) + # set odd bits on digital outputs + k.WriteAllDigital(85) + sleep(1) + # Clear all digital outputs + k.WriteAllDigital(0) + + # and close + k.CloseDevice() + +except IOError: + print "Could not open Device" + + diff --git a/pyk8055/k8055testm.py b/pyk8055/k8055testm.py new file mode 100644 index 0000000..a20dc30 --- /dev/null +++ b/pyk8055/k8055testm.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python +# $Id: k8055testm.py,v 1.1 2007/03/28 10:10:32 pjetur Exp $ +# +# Sample pyton test program for pyk8055 wrapper +# Scanning and testing multiple boards +# +from time import sleep +from pyk8055 import * + +try: + K8055_devices =[] + BMask = SearchDevices() + if not BMask: + print "No K8055 devices found" + exit + + if BMask & 0x01 : K8055_devices.append(k8055(0)) + if BMask & 0x02 : K8055_devices.append(k8055(1)) + if BMask & 0x04 : K8055_devices.append(k8055(2)) + if BMask & 0x08 : K8055_devices.append(k8055(3)) + + for k in K8055_devices: + k.SetCurrentDevice() + # set analog output channel 1 to 200/255*5v = 3.9V + k.OutputAnalogChannel(1,200) + sleep(1) + # set analog output channel low again = 0V + k.OutputAnalogChannel(1,0) + + # read both analog inputs + # note: this returns a list + res = k.ReadAllAnalog() + print "Analog status, board #",k.DeviceAddress(),res[1:] + + # Test class string function + print "Status, board #",k.DeviceAddress(),str(k) + + # Set debounce time on counter 1 + k.SetCounterDebounceTime(1, 100) + + # reset counter 1 + k.ResetCounter(1) + + # Loop creating a rotating display of digital outputs + # Loop 3 times + for i in range(1,3): + for k in K8055_devices: + k.SetCurrentDevice() + d = 1 + k.WriteAllDigital(1) + while d <= 128: # While this running + if k.ReadDigitalChannel(1): + print "Hello world (from board #%d)" %(k.DeviceAddress(),) + sleep(0.2) # wait .2 sec + d *=2 # and continue rotating digital outputs + k.WriteAllDigital(d) + + for k in K8055_devices: + k.SetCurrentDevice() + # read/print the counter on input 1 + print "Board # %d Counter #1=%d" % (k.DeviceAddress(),k.ReadCounter(1)) + # read/print the counter on input 2 + print "Board # %d Counter #2=%d" % (k.DeviceAddress(),k.ReadCounter(2)) + + for k in K8055_devices: + k.SetCurrentDevice() + # set even bits on digital outputs + k.WriteAllDigital(170) + + sleep(1) + + for k in K8055_devices: + k.SetCurrentDevice() + # set odd bits on digital outputs + k.WriteAllDigital(85) + + sleep(1) + + for k in K8055_devices: + k.SetCurrentDevice() + # Clear all digital outputs + k.WriteAllDigital(0) + + # and close + for k in K8055_devices: + k.SetCurrentDevice() + k.CloseDevice() + +except KeyboardInterrupt: + for k in K8055_devices: + k.SetCurrentDevice() + k.WriteAllDigital(0) + k.CloseDevice() + exit + +except IOError: + print "Could not open Device" + diff --git a/pyk8055/libk8055.i b/pyk8055/libk8055.i new file mode 100644 index 0000000..b0d31e9 --- /dev/null +++ b/pyk8055/libk8055.i @@ -0,0 +1,352 @@ +/* $Id: libk8055.i,v 1.3 2007/03/28 10:08:13 pjetur Exp $ + + Copyright (C) 2007 by Pjetur G. Hjaltason + + + Python wrapper for the libk8055 library using "swig" + This file is part of the libk8055 Library. + + The libk8055 Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The libk8055 Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU 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. + + http://opensource.org/licenses/ + +*/ +%module pyk8055 +%include "typemaps.i" + +/* for the ReadAllAnalog and ReadAllValues function */ +%apply long *OUTPUT { long int *data1, long int *data2, long int *data3, long int *data4, long int *data5 }; + +%inline %{ + +/* For direct access to the DEBUG variable and global IO strings */ +extern int DEBUG; +extern unsigned char data_in[9]; +extern unsigned char data_out[9]; +/* + Extended functions for debugging the IO +*/ + +char strval[30]; + +/* returns 16byte hex string - 8 bytes */ +char * RawInput() + { + int i; + for(i=0; i< 8; i++) { + sprintf((char *)&strval[i*2],"%02X",data_in[i]); + } + return (char *)strval; + } + +/* More print friendly format */ +char * DumpInput() + { + int i; + for(i=0; i< 8; i++) { + sprintf((char *)&strval[i*3],"%02X:",data_in[i]); + } + strval[23] = '\0'; + return (char *)strval; + } + +char * DumpOutput() + { + int i; + for(i=0; i< 8; i++) { + sprintf((char *)&strval[i*3],"%02X:",data_out[i]); + } + strval[23] = '\0'; + return (char *)strval; + } +%} + +%{ +extern int OpenDevice (long int BoardAddress); +extern int CloseDevice (void); +extern long int ReadAnalogChannel (long int Channelno); +extern int ReadAllAnalog (long int *data1, long int *data2); +extern int OutputAnalogChannel (long int Channel, long int data); +extern int OutputAllAnalog (long int data1, long int data2); +extern int ClearAllAnalog (void); +extern int ClearAnalogChannel (long int Channel); +extern int SetAnalogChannel (long int Channel); +extern int SetAllAnalog (void); +extern int WriteAllDigital (long int data); +extern int ClearDigitalChannel (long int Channel); +extern int ClearAllDigital (void); +extern int SetDigitalChannel (long int Channel); +extern int SetAllDigital (void); +extern int ReadDigitalChannel (long int Channel); +extern long int ReadAllDigital (void); +extern int ResetCounter (long int counternr); +extern long int ReadCounter (long int CounterNo); +extern int SetCounterDebounceTime (long int CounterNo, long int DebounceTime); +extern int ReadAllValues (long int *data1, long int *data2, long int *data3, long int *data4, long int *data5); +extern int SetAllValues(int digitaldata, int addata1, int addata2); +extern int SetCounterDebounceTime(long CounterNo, long DebounceTime); +extern long SetCurrentDevice(long deviceno); +extern long SearchDevices(void); +extern char *Version(void); + +%} +/* + +And here we create the class interface to the library + +*/ +%pythoncode %{ +K8055_ERROR = -1 +_K8055_CLOSED = -1 + +class k8055: + "Class interface to the libk8055 library" + def __init__(self,BoardAddress=None,debug=False): + """Constructor, optional board open + + k=k8055() # Does not connect to board + k=k8055(1) # Init class and connect to board 1 + k=k8055(1,True) # connect to board 0 and enable debugging + + """ + self.Buttons = 0 + self.dev = _K8055_CLOSED + self.Address = BoardAddress + if debug == False: + self.DebugOff() + else: + self.DebugOn() + if BoardAddress != None: + try: + self.dev = self.OpenDevice(BoardAddress) + # print "Open OK " + str(self.dev) + except: + self.dev = _K8055_CLOSED + raise IOError, "Could not open device" + # print "Open error" + + def __str__(self): + """String format (almost) as from K8055 program""" + if self.__opentest() == True: # Device open + all = self.ReadAllValues() + return str(all[1])+";"+str(all[2])+";"+str(all[3])+";"+str(all[4])+";"+str(all[5]) + else: + return "" + + def __opentest(self): + if self.dev == _K8055_CLOSED: + return False + else: + return True + + def OpenDevice(self,BoardAddress): + """Open the connection to K8055 + + k=k8055() + try; + k.OpenDevice(0) # possible (address 0/1/2/3) + except IOError: + ... + returns 0 if OK, + Throws IOError if invalid board or not accessible + """ + if self.__opentest() == False: # Not open yet + self.dev = _pyk8055.OpenDevice(BoardAddress) + if self.dev == K8055_ERROR: + raise IOError, "Could not open device" + # print "Open OK " + str(self.dev) + return self.dev + + def CloseDevice(self): + """Close the connection to K8055 + + k.CloseDevice() + + retuns 0 if OK else -1 + """ + if self.dev != _K8055_CLOSED: + ret = _pyk8055.CloseDevice() + self.dev = _K8055_CLOSED + return ret + + def OutputAnalogChannel(self,Channel,value=0): + """Set analog output channel value, default 0 (0-255)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.OutputAnalogChannel(Channel,value) + + def ReadAnalogChannel(self,Channel): + """Read data from analog input channel (1/2)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ReadAnalogChannel(Channel) + + def ReadAllAnalog(self): + """Read data from both analog input channels at once + + Returns list, [return-value,channel_data1, channel_data2] + + """ + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ReadAllAnalog() + + def OutputAllAnalog(self,data1,data2): + """Set both analog output channels at once (0-255,0-255)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.OutputAllAnalog(data1,data2) + + def ClearAllAnalog(self): + """Set all (both) analog output channels to 0 (low)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ClearAllAnalog() + + def ClearAnalogChannel(self,Channel): + """Set analog output channel (1/2)to 0 (low)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ClearAnalogChannel(Channel) + + def SetAnalogChannel(self,Channel): + """Set analog output channel (1/2) to 0xFF (high)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetAnalogChannel(Channel) + + def SetAllAnalog(self): + """Set all (both) analog output channels to 0xFF (high)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetAllAnalog() + + def WriteAllDigital(self,data): + """Write digital output channel bitmask (0-255)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.WriteAllDigital(data) + + def ClearDigitalChannel(self,Channel): + """Clear digital output channel (1-8)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ClearDigitalChannel(Channel) + + def ClearAllDigital(self): + """Set all digital output channels low (0)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ClearAllDigital() + + def SetDigitalChannel(self,Channel): + """Set digital output channel (1-8)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetDigitalChannel(Channel) + + def SetAllDigital(self): + """Set all digital output channels high (1)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetAllDigital() + + def ReadDigitalChannel(self,Channel): + """Read digital input channel (1-5), returns 0/1 (-1 on error)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ReadDigitalChannel(Channel) + + def ReadAllDigital(self): + """Read all digital input channels - bitmask + + returns mask 0x00 - 0x1f, 0x01 as channel 1, 0x02 as channel 2... + retuns -1 on error + + """ + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ReadAllDigital() + + def ResetCounter(self,CounterNo): + """Reset input counter (1/2), input channel 1/2""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ResetCounter(CounterNo) + + def ReadCounter(self,CounterNo): + """Read input counter (1/2), input channel 1/2""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ReadCounter(CounterNo) + + def SetCounterDebounceTime(self,CounterNo, DebounceTime): + """Set counter debounce time on counter 1/2 (1-7450 ms)""" + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetCounterDebounceTime(CounterNo,DebounceTime) + + # Makes no sense to switch to another class here + def SetCurrentDevice(self): + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetCurrentDevice(self.Address) + + # This function makes no sense in this context as + # the device is already open + #def SearchDevices(self): + #return _pyk8055.SearchDevices() + + def DeviceAddress(self): + return self.Address + + def IsOpen(self): + return self.__opentest() + + def ReadAllValues(self): + """Read data from all input channels at once + + Returns list, [return-value,digital input data, analog channel_data1, analog channel_data2, counter1, counter2] + + """ + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.ReadAllValues() + def SetAllValues(self,digitaldata, addata1, addata2): + if self.__opentest() == False : return K8055_ERROR + return _pyk8055.SetAllValues(digitaldata, addata1, addata2) + + def Version(self): + return _pyk8055.Version(); + + def DebugOn(self): + _pyk8055.cvar.DEBUG = 1 + def DebugOff(self): + _pyk8055.cvar.DEBUG = 0 + + def RawInput(self): + return _pyk8055.RawInput() + def DumpInput(self): + return "In <-"+_pyk8055.DumpInput() + def DumpOutput(self): + return "Out->"+_pyk8055.DumpOutput() + +%} +extern int OpenDevice (long int BoardAddress); +extern int CloseDevice (void); +extern long int ReadAnalogChannel (long int Channelno); +extern int ReadAllAnalog (long int *data1, long int *data2); +extern int OutputAnalogChannel (long int Channel, long int data); +extern int OutputAllAnalog (long int data1, long int data2); +extern int ClearAllAnalog (void); +extern int ClearAnalogChannel (long int Channel); +extern int SetAnalogChannel (long int Channel); +extern int SetAllAnalog (void); +extern int WriteAllDigital (long int data); +extern int ClearDigitalChannel (long int Channel); +extern int ClearAllDigital (void); +extern int SetDigitalChannel (long int Channel); +extern int SetAllDigital (void); +extern int ReadDigitalChannel (long int Channel); +extern long int ReadAllDigital (void); +extern int ResetCounter (long int counternr); +extern long int ReadCounter (long int CounterNo); +extern int SetCounterDebounceTime (long int CounterNo, long int DebounceTime); +extern int ReadAllValues (long int *data1, long int *data2, long int *data3, long int *data4, long int *data5); +extern int SetAllValues(int digitaldata, int addata1, int addata2); +extern long SetCurrentDevice(long deviceno); +extern long SearchDevices(void); +extern char *Version(void); diff --git a/pyk8055/pyplotA.py b/pyk8055/pyplotA.py new file mode 100755 index 0000000..6d19e29 --- /dev/null +++ b/pyk8055/pyplotA.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python +# $Id: pyplotA.py,v 1.2 2007/03/15 14:55:38 pjetur Exp $ +# +# Simple plotting of analog input data from the K8055 board +# +# based on the running plot sample from pyQwt +# The Python version of qwt-*/examples/data_plot/data_plot.cpp + +import random, sys +from qt import * +from qwt import * +from Numeric import * +from pyk8055 import * + + +class DataPlot(QwtPlot): + + def __init__(self, *args): + QwtPlot.__init__(self, *args) + + # Initialize data + self.x = arrayrange(0.0, 100.1, 0.5) + self.a1 = zeros(len(self.x), Float) + self.a2 = zeros(len(self.x), Float) + + self.setTitle("Simple K8055 datascope") + self.setAutoLegend(True) + + self.curve1 = self.insertCurve("Input 1") + self.curve2 = self.insertCurve("Input 2") + + self.setCurvePen(self.curve1, QPen(Qt.red)) + self.setCurvePen(self.curve2, QPen(Qt.blue)) + + # No automatic scaling, set y-scale 0-255 + self.setAxisScale(QwtPlot.yLeft,0,255,50) + + # set marker line in the middle - value 128 + mY = self.insertLineMarker("", QwtPlot.yLeft) + self.setMarkerYPos(mY, 128.0) + + self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)") + self.setAxisTitle(QwtPlot.yLeft, "Values") + + self.startTimer(50) + + self.k = k8055(0) + # __init__() + + def timerEvent(self, e): + + # data moves from left to right: + # shift data array right and assign new value data[0] + + self.a1 = concatenate((self.a1[:1], self.a1[:-1]), 1) + self.a1[0] = self.k.ReadAnalogChannel(1) + + self.a2 = concatenate((self.a2[:1], self.a2[:-1]), 1) + self.a2[0] = self.k.ReadAnalogChannel(2) + + self.setCurveData(self.curve1, self.x, self.a1) + self.setCurveData(self.curve2, self.x, self.a2) + + self.replot() + + # timerEvent() + +# class DataPlot + +def main(args): + app = QApplication(args) + demo = make() + app.setMainWidget(demo) + app.exec_loop() + +# main() + +def make(): + demo = DataPlot() + demo.resize(500, 300) + demo.show() + return demo + +# make() + +# Admire +if __name__ == '__main__': + main(sys.argv) diff --git a/pyk8055/pyplotA_1.png b/pyk8055/pyplotA_1.png Binary files differnew file mode 100644 index 0000000..56ed71d --- /dev/null +++ b/pyk8055/pyplotA_1.png diff --git a/pyk8055/pyplotD.py b/pyk8055/pyplotD.py new file mode 100755 index 0000000..9145b37 --- /dev/null +++ b/pyk8055/pyplotD.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python +# $Id: pyplotD.py,v 1.2 2007/03/15 14:55:38 pjetur Exp $ +# +# Simple plotting of digital input data from the K8055 board +# +# based on the running plot sample from pyQwt +# The Python version of qwt-*/examples/data_plot/data_plot.cpp + +import random, sys +from qt import * +from qwt import * +from Numeric import * +from pyk8055 import * + +class DataPlot(QwtPlot): + + def __init__(self, *args): + QwtPlot.__init__(self, *args) + + # Initialize data + self.x = arrayrange(0.0, 100.1, 0.5) + self.d1 = 0.0 + zeros(len(self.x), Float) + self.d2 = 1.0 + zeros(len(self.x), Float) # shift data up 1 + self.d3 = 2.0 + zeros(len(self.x), Float) # Shift data up 2... + self.d4 = 3.0 + zeros(len(self.x), Float) + self.d5 = 4.0 + zeros(len(self.x), Float) + + self.setTitle("Simple K8055 datascope") + self.setAutoLegend(True) + + self.curve1 = self.insertCurve("Input 1") + self.curve2 = self.insertCurve("Input 2") + self.curve3 = self.insertCurve("Input 3") + self.curve4 = self.insertCurve("Input 4") + self.curve5 = self.insertCurve("Input 5") + + self.setCurvePen(self.curve1, QPen(Qt.red)) + self.setCurvePen(self.curve2, QPen(Qt.blue)) + self.setCurvePen(self.curve3, QPen(Qt.green)) + self.setCurvePen(self.curve4, QPen(Qt.black)) + self.setCurvePen(self.curve5, QPen(Qt.cyan)) + + # Make data plot shape square + self.setCurveStyle(self.curve1, QwtCurve.Steps) + self.setCurveStyle(self.curve2, QwtCurve.Steps) + self.setCurveStyle(self.curve3, QwtCurve.Steps) + self.setCurveStyle(self.curve4, QwtCurve.Steps) + self.setCurveStyle(self.curve5, QwtCurve.Steps) + + # Fixed axis here from 0 to 5 + self.setAxisScale(QwtPlot.yLeft,0,5,1) + + self.setAxisTitle(QwtPlot.xBottom, "Time (seconds)") + self.setAxisTitle(QwtPlot.yLeft, "Values") + + self.startTimer(50) + + # init the K8055 board + self.k = k8055(0) + # __init__() + + def timerEvent(self, e): + + # data moves from left to right: + # shift data array right and assign new value data[0] + + self.d1 = concatenate((self.d1[:1], self.d1[:-1]), 1) + self.d1[0] = self.k.ReadDigitalChannel(1) * 0.95 + + self.d2 = concatenate((self.d2[:1], self.d2[:-1]), 1) + self.d2[0] = self.k.ReadDigitalChannel(2) * 0.95 + 1 # Shift data up 1 + + self.d3 = concatenate((self.d3[:1], self.d3[:-1]), 1) + self.d3[0] = self.k.ReadDigitalChannel(3) * 0.95 + 2 # Shift data up 2... + + self.d4 = concatenate((self.d4[:1], self.d4[:-1]), 1) + self.d4[0] = self.k.ReadDigitalChannel(4) * 0.95 + 3 + + self.d5 = concatenate((self.d5[:1], self.d5[:-1]), 1) + self.d5[0] = self.k.ReadDigitalChannel(5) * 0.95 + 4 + + self.setCurveData(self.curve1, self.x, self.d1) + self.setCurveData(self.curve2, self.x, self.d2) + self.setCurveData(self.curve3, self.x, self.d3) + self.setCurveData(self.curve4, self.x, self.d4) + self.setCurveData(self.curve5, self.x, self.d5) + + self.replot() + + # timerEvent() + +# class DataPlot + +def main(args): + app = QApplication(args) + demo = make() + app.setMainWidget(demo) + app.exec_loop() + +# main() + +def make(): + demo = DataPlot() + demo.resize(500, 300) + demo.show() + return demo + +# make() + +# Admire +if __name__ == '__main__': + main(sys.argv) + diff --git a/pyk8055/pyplotD_2.png b/pyk8055/pyplotD_2.png Binary files differnew file mode 100644 index 0000000..1603cf4 --- /dev/null +++ b/pyk8055/pyplotD_2.png diff --git a/pyk8055/setup.py b/pyk8055/setup.py new file mode 100644 index 0000000..b1a1c85 --- /dev/null +++ b/pyk8055/setup.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python + +import os,sys,string +from distutils.core import setup, Extension + +__revision__ = "$Id: setup.py,v 1.3 2007/03/28 10:17:57 pjetur Exp $" + +if os.environ.has_key('VERSION'): + version=os.environ['VERSION'] +else: + from subprocess import * + try: + version = Popen(["grep ^VERSION ../Makefile | cut -d '=' -f 2 | tr -d '\n'"], stdout=PIPE, shell=True).communicate()[0] + except: + version='?.?' + +build_modules = [Extension('_pyk8055', + define_macros = [('VERSION', "\"%s\"" % str(version))], + libraries=["usb"], + sources=['libk8055.i',"../libk8055.c"])] + +setup( + name='pyk8055', + version=version, + author='Pjetur G. Hjaltason', + author_email='pjetur@pjetur.net', + description='K8055 library wrapper', + url='http://libk8055.sourceforge.net/', + ext_modules =build_modules, + py_modules=['pyk8055'] +) diff --git a/velleman.rules b/velleman.rules new file mode 100644 index 0000000..f1afc8f --- /dev/null +++ b/velleman.rules @@ -0,0 +1,19 @@ +# velleman.rules a udev rules file for velleman K8055/VM110. +# Put this file in /etc/udev/rules.d +# +# To access the devices under a regular user account, you must +# be in the k8055 group. +# +# You can add a RUN="..." attribute to run some arbitrary script +# when the device is plugged in. + +SUBSYSTEM !="usb_device", ACTION !="add", GOTO="velleman_rules_end" + +SYSFS{idVendor}=="10cf", SYSFS{idProduct}=="5500", SYMLINK+="k8055_0" +SYSFS{idVendor}=="10cf", SYSFS{idProduct}=="5501", SYMLINK+="k8055_1" +SYSFS{idVendor}=="10cf", SYSFS{idProduct}=="5502", SYMLINK+="k8055_2" +SYSFS{idVendor}=="10cf", SYSFS{idProduct}=="5503", SYMLINK+="k8055_3" + +MODE="0660", GROUP="k8055" + +LABEL="velleman_rules_end" |
