sicl 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+= 0.1.0 2007-05-12
+
+* Birthday!

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+
+ext/sicl.c
+ext/extconf.rb
+test/test_sicl.rb

data/README.txt

@@ -0,0 +1,71 @@
+SICL/Ruby
+    http://rubyforge.org/projects/sicl/
+
+== DESCRIPTION:
+
+SICL/Ruby is SICL(Standard Instrument Control Library) API module for 
+Ruby. SICL is part of the Agilent IO Libraries Suite product. SICL/Ruby
+gives you a capability to control your instruments via GPIB, USB, and LAN.
+
+== SYNOPSIS:
+
+  require 'sicl'
+  
+  SICL.open('gpib0,17') do |io|
+    
+    io.output('*IDN?')
+
+    puts io.enter
+    
+    # ... instruments specific operations ...
+    
+  end
+
+or
+
+  require 'sicl'
+  
+  io = SICL.open('gpib0,17')
+  
+  io.output('*RST')
+
+  puts io.spoll
+
+  puts io.query('*IDN?')
+  
+  # ... instruments specific operations ...
+  
+  io.close
+
+or
+
+  require 'sicl'
+  
+  class MyInst < SICL::Instrument
+    def reset; output('*RST'); end
+  end
+  
+  io = MyInst.new 'gpib0,17'
+  
+  io.reset
+  
+  # ... instruments specific operations ...
+  
+  io.close
+
+== REQUIREMENTS:
+
+* Aiglent IO Libraries Suite 14.2
+
+Agilent Technologies
+    http://www.home.agilent.com
+
+== INSTALL:
+
+* sudo gem install sicl
+
+== LICENSE:
+
+(GPL ver.2)
+
+Copyright (c) 2007, Naoki Kobayashi

data/Rakefile

@@ -0,0 +1,47 @@
+################################################################################
+#
+#   Copyright (c) 2007 Naoki Kobayashi
+#
+#   This library is free software. ( except for SICL Library )
+#   You can distribute/modify this file under the same terms of ruby.
+#
+#   $Header: $
+#
+################################################################################
+
+begin
+  require 'rubygems'
+  require 'rake/gempackagetask'
+rescue Exception
+  nil
+end
+
+require "rake/clean"
+require "rake/gempackagetask"
+
+PKG_FILES = []
+File.open("Manifest.txt") do |manifest|
+  manifest.each do |file|
+    PKG_FILES << file.chomp if file =~ /\w+/
+  end
+end
+
+task :default => :package
+
+spec = Gem::Specification.new do |s|
+  s.name = "sicl"
+  s.version = "0.1.0"
+  s.summary = "Agilent SICL API module for Ruby."
+  s.autorequire = "sicl"
+  s.files = PKG_FILES
+  s.default_executable = "ext/extconf.rb"
+  s.extensions = ["ext/extconf.rb"]
+  s.description = <<EOF
+SICL/Ruby is SICL(Standard Instrument Control Library) API module for Ruby. SICL is part of the Agilent IO Libraries Suite product. SICL/Ruby gives you a capability to control your instruments via GPIB, USB, and LAN.
+EOF
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar_bz2 = true
+    pkg.need_tar_gz = true
+end

data/ext/extconf.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/ruby -W0
+
+# temporary solution for cygwin
+case RUBY_PLATFORM
+when "i386-cygwin"
+  # default file location settings
+  SICL_DIR = "/cygdrive/c/Program Files/Agilent/IO Libraries Suite"
+  SICL_LIB_DIR = "#{SICL_DIR}/lib"
+  SICL_INC_DIR = "#{SICL_DIR}/include"
+  SICL32LIB = "sicl32.lib"
+  # target options
+  SICL_LIB_OPT = "--with-sicl-lib"
+  SICL_INC_OPT = "--with-sicl-include"
+
+  ARGV.delete_if do |arg|
+    case arg
+    when /^(#{SICL_INC_OPT}=)(.*)/
+      SICL_INC_DIR = $2
+      true
+    when /^(#{SICL_LIB_OPT}=)(.*)/
+      SICL_LIB_DIR = $2
+      true
+    else
+      false
+    end
+  end
+
+  ARGV << "#{SICL_INC_OPT}=#{SICL_INC_DIR}"
+  ARGV << "#{SICL_LIB_OPT}=."
+  SICL32LIB = "#{SICL_LIB_DIR}/#{SICL32LIB}"
+
+  raise IOError.new("'#{SICL32LIB}': No such file") unless File.exist?(SICL32LIB)
+
+  # convert dynamic link library to static link library
+  `printf 'NAME sicl32.dll\nEXPORTS\n' >x.def`
+  `nm -g --defined '#{SICL32LIB}' | sed -n '/00000000 I __imp__/s///p' >>x.def`
+  `dlltool --def=x.def --output-lib=libsicl.a`
+  `rm x.def`
+else
+end
+
+require 'mkmf'
+
+dir_config('sicl')
+
+if have_header('sicl.h') and have_library('sicl')
+  create_makefile('sicl')
+end
+

data/ext/sicl.c

@@ -0,0 +1,710 @@
+/*
+ *   Copyright (c) 2005-2006 Naoki Kobayashi
+ *
+ *   This library is free software. ( except for SICL Library )
+ *   You can distribute/modify this file under the same terms of ruby.
+ *
+ *   $Header: $
+ *
+ */
+
+#define _REENT_ONLY
+
+#include <ruby.h>
+#include "sicl.h"
+
+/* -----------------------------------------------------------------------
+                          File Local Variables
+----------------------------------------------------------------------- */
+
+/* prototype of class and module */
+static VALUE mSicl;
+static VALUE cInstrument;
+static VALUE eSicl;
+
+/* hash table of internal configurations */
+static VALUE gConfig;
+
+/* id of event handlers */
+static ID s_errhdlr;
+static ID s_srqhdlr;
+static ID s_intrhdlr;
+
+/* id of 'call' method of Proc object */
+static ID s_call;
+
+/* id of 'buf_mode' method of SICL::Instrument object */
+static ID s_buf_mode;
+
+static const VALUE READ_ALL_DATA = INT2FIX(-1);
+
+/* -----------------------------------------------------------------------
+                       struct cparse_params
+----------------------------------------------------------------------- */
+
+struct instrument {
+    INST id;
+    int errno;
+};
+
+/* -----------------------------------------------------------------------
+                              Utils
+----------------------------------------------------------------------- */
+
+#define CLEAR_ERROR(inst) do { inst->errno=0; } while(0)
+
+VALUE sicl_return ( VALUE self, struct instrument * inst, int error )
+{
+    if ( error ) {
+        inst->errno = error;
+    } else {
+        inst->errno = 0;
+    }
+
+    return error ? Qnil : self;
+}
+
+/* -----------------------------------------------------------------------
+                        SICL wrapper Main Routines
+----------------------------------------------------------------------- */
+
+static VALUE sicl_close  ( VALUE self )
+{
+    rb_funcall ( self, rb_intern("close"), 0, 0 );
+}
+
+/* error handler ( dummy ) for sicl_enter () */
+static void SICLCALLBACK dmy_handler ( INST id, int error )
+{
+    ; /* do nothing. */
+}
+
+/* error handler */
+static void SICLCALLBACK err_handler ( INST id, int error )
+{
+    VALUE self = rb_hash_aref ( gConfig, INT2FIX(id) );
+    VALUE hdlr = rb_ivar_get ( self, s_errhdlr );
+
+    if ( ! NIL_P(self) ) {
+        /* save error code */
+        struct instrument * inst = NULL;
+        Data_Get_Struct ( self, struct instrument, inst );
+        inst->errno = error;
+    }
+
+    if ( ! NIL_P(hdlr) ) {
+        VALUE err = rb_ary_new ();
+        rb_ary_push ( err, INT2FIX(error) );
+        rb_ary_push ( err, rb_str_new2(igeterrstr(error)) );
+
+        rb_funcall ( hdlr, s_call, 1, err );
+    } else {
+        rb_raise ( eSicl, igeterrstr(error) );
+    }
+}
+
+/* srq handler */
+static void SICLCALLBACK srq_handler ( INST id )
+{
+    VALUE self = rb_hash_aref ( gConfig, INT2FIX(id) );
+    VALUE hdlr = rb_ivar_get ( self, s_srqhdlr );
+
+    if ( ! NIL_P(hdlr) )
+        rb_funcall ( hdlr, s_call, 0 );
+}
+
+/* interrupt handler */
+static void SICLCALLBACK intr_handler ( INST id, long reason, long secval )
+{
+    VALUE self = rb_hash_aref ( gConfig, INT2FIX(id) );
+    VALUE hdlr = rb_ivar_get ( self, s_srqhdlr );
+
+    if ( ! NIL_P(hdlr) )
+        rb_funcall ( hdlr, s_call, 2, INT2FIX(reason), INT2FIX(secval) );
+}
+
+VALUE sicl_igeterrstr ( int argc, VALUE * argv, VALUE self )
+{
+    VALUE code = 0;
+
+    rb_scan_args ( argc, argv, "01", & code );
+
+    if ( TYPE(code)!=T_FIXNUM ) {
+        struct instrument * inst = NULL;
+
+        Data_Get_Struct ( self, struct instrument, inst );
+
+        if ( ! inst->errno ) return Qnil;
+
+        code = INT2FIX ( inst->errno );
+    }
+
+    if ( NIL_P(code) ) return code;
+
+    return rb_str_new2 ( igeterrstr ( FIX2INT ( code ) ) );
+}
+
+VALUE sicl_ionerror ( VALUE self, VALUE proc )
+{
+    if ( NIL_P(proc) || CLASS_OF(proc)==rb_cProc ) {
+
+        rb_ivar_set ( self, s_errhdlr, proc );
+
+    } else {
+
+        rb_raise ( rb_eTypeError, "Need a block or nil" );
+
+    }
+
+    return self;
+}
+
+VALUE sicl_igetonerror ( VALUE self )
+{
+    if ( rb_block_given_p() ) {
+
+        rb_ivar_set ( self, s_errhdlr, rb_block_proc() );
+
+        return self;
+
+    } else {
+
+        return rb_ivar_get ( self, s_errhdlr );
+
+    }
+}
+
+VALUE sicl_ionsrq ( VALUE self, VALUE proc )
+{
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    if ( NIL_P(proc) ) {
+
+        rb_ivar_set ( self, s_srqhdlr, proc );
+        ionsrq ( inst->id, 0 );
+
+    } else if ( CLASS_OF(proc)==rb_cProc ) {
+
+        rb_ivar_set ( self, s_srqhdlr, proc );
+        ionsrq ( inst->id, srq_handler );
+
+    } else {
+
+        rb_raise ( rb_eTypeError, "Need a block or nil" );
+
+    }
+
+    return self;
+}
+
+VALUE sicl_igetonsrq ( VALUE self )
+{
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    if ( rb_block_given_p() ) {
+
+        rb_ivar_set ( self, s_srqhdlr, rb_block_proc() );
+        ionsrq ( inst->id, srq_handler );
+
+        return self;
+
+    } else {
+
+        return rb_ivar_get ( self, s_srqhdlr );
+
+    }
+}
+
+VALUE sicl_ionintr ( VALUE self, VALUE proc )
+{
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    if ( NIL_P(proc) ) {
+
+        rb_ivar_set ( self, s_intrhdlr, proc );
+        ionintr ( inst->id, 0 );
+
+    } else if ( CLASS_OF(proc)==rb_cProc ) {
+
+        rb_ivar_set ( self, s_intrhdlr, proc );
+        ionintr ( inst->id, intr_handler );
+
+    } else {
+
+        rb_raise ( rb_eTypeError, "Need a block or nil" );
+
+    }
+
+    return self;
+}
+
+VALUE sicl_igetonintr ( VALUE self )
+{
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    if ( rb_block_given_p() ) {
+
+        rb_ivar_set ( self, s_intrhdlr, rb_block_proc() );
+        ionintr ( inst->id, intr_handler );
+
+        return self;
+
+    } else {
+
+        return rb_ivar_get ( self, s_intrhdlr );
+
+    }
+}
+
+VALUE sicl_s_allocate ( VALUE klass )
+{
+    VALUE self = 0;
+    struct instrument * inst = NULL;
+
+    self = Data_Make_Struct ( klass, struct instrument, 0, 0, inst );
+
+    rb_ivar_set ( self, s_errhdlr, Qnil );
+    rb_ivar_set ( self, s_srqhdlr, Qnil );
+    rb_ivar_set ( self, s_intrhdlr, Qnil );
+    rb_ivar_set ( self, s_buf_mode, Qnil );
+
+    return self;
+}
+
+VALUE sicl_iopen ( VALUE self, VALUE addr )
+{
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    Check_Type ( addr, T_STRING );
+
+    inst->id = iopen ( RSTRING(addr)->ptr );
+    itimeout ( inst->id, 5000 );
+
+    rb_hash_aset ( gConfig, INT2FIX(inst->id), self );
+
+    CLEAR_ERROR ( inst );
+
+    if ( rb_block_given_p() ) {
+        return rb_ensure(rb_yield, self, sicl_close, self);
+    }
+
+    return self;
+}
+
+VALUE sicl_s_iopen ( VALUE klass, VALUE addr )
+{
+    VALUE self = sicl_s_allocate (cInstrument);
+
+    return sicl_iopen ( self, addr );
+}
+
+VALUE sicl_initialize ( VALUE self, VALUE addr )
+{
+    return sicl_iopen ( self, addr );
+}
+
+VALUE sicl_itimeout ( VALUE self, VALUE ms )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+
+    Check_Type ( ms, T_FIXNUM );
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = itimeout ( inst->id, FIX2INT(ms) );
+
+    return sicl_return ( self, inst, err );
+}
+
+VALUE sicl_igettimeout ( VALUE self )
+{
+    int err   = 0;
+    long tval = 0;
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = igettimeout ( inst->id, & tval );
+
+    return sicl_return ( INT2FIX(tval), inst, err );
+}
+
+VALUE sicl_set_buf_mode ( VALUE self, VALUE enabled )
+{
+    if ( NIL_P(enabled) )
+        rb_ivar_set ( self, s_buf_mode, Qnil );
+    else if ( TYPE(enabled)==T_FALSE )
+        rb_ivar_set ( self, s_buf_mode, Qfalse );
+    else
+        rb_ivar_set ( self, s_buf_mode, Qtrue );
+
+    return self;
+}
+
+VALUE sicl_get_buf_mode ( VALUE self )
+{
+    return rb_ivar_get ( self, s_buf_mode );
+}
+
+VALUE sicl_iwrite ( VALUE self, VALUE cmd, VALUE eoi )
+{
+    int err                  = 0;
+    struct instrument * inst = NULL;
+    int endi                 = 0; /* send END indicator, or not */
+    unsigned long actualcnt  = 0;
+    char * ptr               = NULL;
+    long len                 = 0;
+
+    int ( * write )( INST, char *, unsigned long, int, unsigned long * ) = iwrite;
+
+    Check_Type ( cmd, T_STRING );
+
+    if ( TYPE(eoi)==T_TRUE ) endi = 1;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    ptr = RSTRING(cmd)->ptr;
+    len = RSTRING(cmd)->len;
+
+    if ( rb_ivar_get( self, s_buf_mode )==Qtrue ) write = ifwrite;
+
+    while ( len>0 ) {
+        err = write ( inst->id, ptr, len, endi, & actualcnt );
+
+        if ( err ) break;
+
+        ptr += actualcnt;
+        len -= actualcnt;
+    }
+
+    return sicl_return ( self, inst, err );
+}
+
+VALUE sicl_iwrite_arg ( int argc, VALUE * argv, VALUE self )
+{
+    VALUE cmd = 0;
+    VALUE eoi = 0;
+
+    rb_scan_args ( argc, argv, "11", & cmd, & eoi );
+
+    return sicl_iwrite ( self, cmd, eoi );
+}
+
+VALUE sicl_iread ( VALUE self, VALUE max )
+{
+    int err                  = 0;
+    struct instrument * inst = NULL;
+    char buf[0x100];
+    int size                 = sizeof(buf)-1;
+    int len                  = NUM2INT(READ_ALL_DATA);
+    int reason               = 0;
+    unsigned long actualcnt  = 0;
+
+    int ( * read )( INST, char *, unsigned long, int *, unsigned long *) = iread;
+
+    VALUE str = rb_str_new2 ("");
+
+    buf[0] = '\0';
+
+    if ( ! NIL_P(max) ) len = NUM2INT(max);
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    if ( rb_ivar_get( self, s_buf_mode )==Qtrue ) read = ifread;
+
+    for (;;) {
+        if ( len==0 ) break;
+
+        if ( 0<len && len<size ) size = len;
+
+        err = read ( inst->id, buf, size, & reason, & actualcnt );
+
+        if ( err && err!=I_ERR_TIMEOUT ) break;
+
+        len -= actualcnt;
+        rb_str_cat ( str, buf, actualcnt );
+
+        if ( err==I_ERR_TIMEOUT ) {
+            if ( RSTRING(str)->len>0 ) err = I_ERR_NOERROR;
+            break;
+        }
+        if ( reason==I_TERM_END ) break;
+        if ( reason==I_TERM_CHR ) break;
+    }
+
+    return sicl_return ( str, inst, err );
+}
+
+VALUE sicl_iread_arg ( int argc, VALUE * argv, VALUE self )
+{
+    VALUE max = 0;
+
+    rb_scan_args ( argc, argv, "01", & max );
+
+    return sicl_iread ( self, max );
+}
+
+VALUE sicl_output ( VALUE self, VALUE cmd )
+{
+    VALUE tmp  = 0;
+    VALUE eoi  = Qtrue;
+    VALUE reg1 = 0;
+    VALUE reg2 = 0;
+    VALUE blnk = 0;
+    ID s_gsub = 0;
+
+    Check_Type ( cmd, T_STRING );
+
+    reg1    = rb_reg_new ( "[\\s;]*$", 7, 0 );
+    reg2    = rb_reg_new ( "^[\\s;]*", 7, 0 );
+    blnk    = rb_str_new2 ( "" );
+    s_gsub = rb_intern ( "gsub" );
+
+    tmp = rb_funcall ( cmd, s_gsub, 2, reg1, blnk );
+    cmd = rb_funcall ( tmp, s_gsub, 2, reg2, blnk );
+
+    rb_str_cat2 ( cmd, "\r\n" );
+
+    self = sicl_iwrite ( self, cmd, eoi );
+
+    return self;
+}
+
+VALUE sicl_enter ( VALUE self )
+{
+    VALUE str   = 0;
+    const ID s_chomp = rb_intern ( "chomp" );
+
+    ionerror ( dmy_handler );
+
+    str = sicl_iread ( self, READ_ALL_DATA );
+
+    ionerror ( err_handler );
+
+    if ( NIL_P(str) ) return Qnil;
+
+    str = rb_funcall ( str, s_chomp, 0 );
+
+    return str;
+}
+
+VALUE sicl_enter2 ( VALUE self, VALUE out )
+{
+    VALUE str  = 0;
+    const VALUE reg  = rb_reg_new ( ".*", 2, 0 );
+    const ID s_gsub = rb_intern  ( "gsub!" );
+
+    Check_Type ( out, T_STRING );
+
+    str = sicl_enter ( self );
+
+    if ( NIL_P(str) ) return Qnil;
+
+    rb_funcall ( out, s_gsub, 2, reg, str );
+
+    return self;
+}
+
+VALUE sicl_query ( VALUE self, VALUE cmd )
+{
+    self = sicl_output ( self, cmd );
+
+    return NIL_P(self) ? Qnil : sicl_enter ( self );
+}
+
+VALUE sicl_ireadstb ( VALUE self )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+    unsigned char stb        = 0;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = ireadstb ( inst->id, & stb );
+
+    return sicl_return ( INT2FIX( stb ), inst, err );
+}
+
+int sicl_func ( VALUE self, int (*func)( INST ) )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = func ( inst->id );
+
+    return sicl_return ( self, inst, err );
+}
+
+VALUE sicl_iclose  ( VALUE self )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+    INST id = 0;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    id = inst->id;
+
+    err = iclose ( inst->id );
+
+    if ( !err )
+        rb_hash_delete ( gConfig, INT2FIX(id) );
+
+    return !err ? Qtrue : Qfalse;
+}
+
+VALUE sicl_iflush  ( int argc, VALUE * argv, VALUE self )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+    VALUE mask = 0;
+
+    rb_scan_args ( argc, argv, "01", & mask );
+
+    if ( NIL_P(mask) ) mask = INT2FIX( I_BUF_READ | I_BUF_WRITE_END );
+
+    Check_Type ( mask, T_FIXNUM );
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = iflush ( inst->id, FIX2INT(mask) );
+
+    return sicl_return ( self, inst, err );
+}
+
+VALUE sicl_igetaddr  ( VALUE self )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+    char * addr = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = igetaddr ( inst->id, & addr );
+
+    return sicl_return ( rb_str_new2 ( addr ), inst, err );
+}
+
+VALUE sicl_itermchr  ( VALUE self, VALUE tchr )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    Check_Type ( tchr, T_FIXNUM );
+
+    err = itermchr ( inst->id, FIX2INT(tchr) );
+
+    return sicl_return ( self, inst, err );
+}
+
+VALUE sicl_igettermchr  ( VALUE self )
+{
+    int err = 0;
+    struct instrument * inst = NULL;
+    int tchr = 0;
+
+    Data_Get_Struct ( self, struct instrument, inst );
+
+    err = igettermchr ( inst->id, & tchr );
+
+    return sicl_return ( INT2FIX ( tchr ), inst, err );
+}
+
+VALUE sicl_iabort  ( VALUE self ) { sicl_func ( self, iabort ); }
+VALUE sicl_iclear  ( VALUE self ) { sicl_func ( self, iclear ); }
+VALUE sicl_ilocal  ( VALUE self ) { sicl_func ( self, ilocal ); }
+VALUE sicl_iremote ( VALUE self ) { sicl_func ( self, iremote ); }
+VALUE sicl_ilock   ( VALUE self ) { sicl_func ( self, ilock ); }
+VALUE sicl_iunlock ( VALUE self ) { sicl_func ( self, iunlock ); }
+VALUE sicl_itrigger ( VALUE self ) { sicl_func ( self, itrigger ); }
+
+/* -----------------------------------------------------------------------
+                          Ruby Interface
+----------------------------------------------------------------------- */
+
+void Init_sicl ()
+{
+    mSicl = rb_define_module ( "SICL" );
+
+    rb_define_module_function( mSicl, "open", sicl_s_iopen, 1 );
+
+    rb_define_const ( mSicl, "BUF_READ"         , INT2FIX(I_BUF_READ)          );
+    rb_define_const ( mSicl, "BUF_WRITE"        , INT2FIX(I_BUF_WRITE)         );
+    rb_define_const ( mSicl, "BUF_WRITE_END"    , INT2FIX(I_BUF_WRITE_END)     );
+    rb_define_const ( mSicl, "BUF_DISCARD_READ" , INT2FIX(I_BUF_DISCARD_READ)  );
+    rb_define_const ( mSicl, "BUF_DISCARD_WRITE", INT2FIX(I_BUF_DISCARD_WRITE) );
+
+    eSicl = rb_define_class_under ( mSicl, "Error", rb_eStandardError );
+
+    ionerror ( err_handler );
+
+    s_call = rb_intern ( "call" );
+
+    s_buf_mode = rb_intern ( "buf_mode" );
+
+    s_errhdlr  = rb_intern ( "errhdlr"  );
+    s_srqhdlr  = rb_intern ( "srqhdlr"  );
+    s_intrhdlr = rb_intern ( "intrhdlr" );
+
+    gConfig = rb_hash_new ();
+    rb_global_variable( & gConfig );
+
+    cInstrument = rb_define_class_under ( mSicl, "Instrument", rb_cObject );
+
+    rb_define_alloc_func ( cInstrument, sicl_s_allocate );
+
+    rb_define_method ( cInstrument, "initialize" , sicl_initialize, 1 );
+    rb_define_method ( cInstrument, "close" , sicl_iclose    ,  0 );
+    rb_define_method ( cInstrument, "write" , sicl_iwrite_arg, -1 );
+    rb_define_method ( cInstrument, "read"  , sicl_iread_arg , -1 );
+    rb_define_method ( cInstrument, "spoll" , sicl_ireadstb  ,  0 );
+    rb_define_method ( cInstrument, "flush" , sicl_iflush    ,  -1 );
+
+    rb_define_method ( cInstrument, "timeout=", sicl_itimeout   ,  1 );
+    rb_define_method ( cInstrument, "timeout" , sicl_igettimeout,  0 );
+    rb_define_method ( cInstrument, "termchr=", sicl_itermchr   ,  1 );
+    rb_define_method ( cInstrument, "termchr" , sicl_igettermchr,  0 );
+    rb_define_method ( cInstrument, "addr"    , sicl_igetaddr   ,  0 );
+    rb_define_method ( cInstrument, "address" , sicl_igetaddr   ,  0 );
+    rb_define_method ( cInstrument, "errstr"  , sicl_igeterrstr , -1 );
+
+    rb_define_method ( cInstrument, "output" , sicl_output, 1 );
+    rb_define_method ( cInstrument, "enter"  , sicl_enter , 0 );
+    rb_define_method ( cInstrument, "query"  , sicl_query , 1 );
+    rb_define_method ( cInstrument, "<<"     , sicl_output, 1 );
+    rb_define_method ( cInstrument, ">>"     , sicl_enter2, 1 );
+
+    rb_define_method ( cInstrument, "abort"  , sicl_iabort  , 0 );
+    rb_define_method ( cInstrument, "clear"  , sicl_iclear  , 0 );
+    rb_define_method ( cInstrument, "local"  , sicl_ilocal  , 0 );
+    rb_define_method ( cInstrument, "remote" , sicl_iremote , 0 );
+    rb_define_method ( cInstrument, "lock"   , sicl_ilock   , 0 );
+    rb_define_method ( cInstrument, "unlock" , sicl_iunlock , 0 );
+    rb_define_method ( cInstrument, "trigger", sicl_itrigger, 0 );
+
+    rb_define_method ( cInstrument, "on_error=", sicl_ionerror   , 1 );
+    rb_define_method ( cInstrument, "on_error" , sicl_igetonerror, 0 );
+    rb_define_method ( cInstrument, "on_srq="  , sicl_ionsrq     , 1 );
+    rb_define_method ( cInstrument, "on_srq"   , sicl_igetonsrq  , 0 );
+    rb_define_method ( cInstrument, "on_intrrupt=" , sicl_ionintr    , 1 );
+    rb_define_method ( cInstrument, "on_intrrupt"  , sicl_igetonintr , 0 );
+
+    /* accessor for @buf_mode */
+    rb_define_method ( cInstrument, "buf_mode=", sicl_set_buf_mode, 1 );
+    rb_define_method ( cInstrument, "buf_mode" , sicl_get_buf_mode, 0 );
+}

data/test/test_sicl.rb

@@ -0,0 +1,373 @@
+#!/usr/bin/ruby
+################################################################################
+#
+#   Copyright (c) 2005-2006 Naoki Kobayashi
+#
+#   This library is free software.
+#   You can distribute/modify this script under the same terms of ruby.
+#
+#   $Header: $
+#
+################################################################################
+
+################################################################################
+# OPTION SETTINGS
+################################################################################
+
+require "optparse"
+
+Settings = Hash.new
+opts = OptionParser.new
+opts.on( "-a", "--address ADDRESS", String ) { |v| Settings[:address] = v }
+opts.parse!( ARGV )
+
+################################################################################
+# PARAMETER VALIDATION
+################################################################################
+
+address = Settings[:address]
+address = "gpib0,17" unless address
+
+################################################################################
+# CLASS DECLARATION
+################################################################################
+
+require "runit/testcase"
+require "runit/cui/testrunner"
+require "sicl"
+
+class TestSicl < RUNIT::TestCase
+
+  def TestSicl.suite(address)
+    @@address = address
+    @@idn_str = SICL.open(@@address).query("*idn?")
+    super()
+  end
+
+  class MyInstrument < SICL::Instrument
+
+    def initialize(addr)
+      super(addr)
+
+      reset
+      enable_srq_detection
+    end
+
+    def reset
+      output "*cls"
+      output "*rst"
+      query "*esr?"
+    end
+
+    def enable_srq_detection
+      output "*sre #{0x20}"
+      output "*ese #{0x3c}"
+    end
+
+    def raise_timeout(timeout=1000)
+      self.timeout = timeout
+      loop { break unless self.read }
+    end
+
+    def raise_srq(timeout=10)
+      self.output "xxx"
+      sleep timeout
+    end
+
+  end
+
+  NO_ERROR         = "No error"
+  BAD_ADDRESS      = "Bad address"
+  TIMEOUT_OCCURRED = "Timeout occurred"
+  INVALID_INST     = "Invalid INST"
+
+  ESR_BIT = 5 # Standard Event Register
+  RQS_BIT = 6 # ReQuest Service
+
+  def setup
+    @exp = {}
+    @exp[:str] = @@idn_str
+    @exp[:chr] = @exp[:str][0].chr
+    @exp[:rgx] = /^#{@exp[:str]}/
+
+    @inst = MyInstrument.new @@address
+  end
+
+  def teardown
+
+    begin
+      @inst.on_error = nil
+      @inst.on_srq = nil
+    rescue
+      # do nothing...
+    end
+
+  end
+
+  def test_open0
+    ret = SICL.open(@@address) { |io|
+
+      res = io.write("*idn?\n").read
+      assert_match @exp[:rgx], res
+
+      res = io.output("*idn?").enter
+      assert_match @exp[:rgx], res
+
+      res = io.query("*idn?")
+      assert_match @exp[:rgx], res
+
+      io.address
+    }
+
+    assert_equal @@address, ret
+  end
+
+  def test_open1
+    err = assert_exception(SICL::Error) { SICL.open("xxx") }
+
+    assert_equal BAD_ADDRESS, err.message
+  end
+
+  def test_stb0
+    @inst.output("*sre #{0x00}")
+    @inst.output("*ese #{0x00}")
+
+    rqs = @inst.query("*stb?").to_i[RQS_BIT]
+    assert_equal 0, rqs
+  end
+
+  def test_stb1
+    @inst.output("xxx")
+
+    sleep 0.1
+
+    stb = @inst.query("*stb?").to_i
+
+    assert_equal 1, stb[ESR_BIT]
+    assert_equal 1, stb[RQS_BIT]
+  end
+
+  def test_stb2
+    @inst.output("xxx")
+
+    sleep 1
+
+    stb = @inst.spoll
+
+    assert_equal 1, stb[ESR_BIT]
+    assert_equal 1, stb[RQS_BIT]
+  end
+
+  def test_srq0
+    srq_occured = false
+
+    @inst.on_srq { srq_occured = true }
+
+    @inst.output("xxx")
+
+    10.times { sleep 0.1 until srq_occured }
+
+    assert_equal true, srq_occured
+  end
+
+  def test_srq1
+    stb = 0
+
+    @inst.on_srq { sleep 1; stb = @inst.spoll }
+
+    @inst.output("xxx")
+
+    10.times { sleep 0.1 if stb == 0 }
+
+    assert_equal 1, stb[ESR_BIT]
+    assert_equal 1, stb[RQS_BIT]
+  end
+
+  def test_write_and_read0
+    res = @inst.write("*idn?\n")
+    assert res
+
+    res = @inst.read 1
+    assert_equal @exp[:chr], res
+  end
+  def test_write_and_read1
+    res = @inst.write("*idn?\n").read 1
+    assert_equal @exp[:chr], res
+  end
+  def test_write_and_read2
+    res = @inst.write("*idn?\n").read 7
+    assert_equal @exp[:str][0...7], res
+  end
+  def test_write_and_read3
+    res = @inst.write("*i").write("dn").write("?\n").read 1
+    assert_equal @exp[:chr], res
+  end
+
+  def test_output_and_enter0
+    res = @inst.output("*idn?")
+    assert res
+    res = @inst.enter
+    assert_match @exp[:rgx], res
+  end
+
+  def test_output_and_enter1
+    res = @inst.output("*idn?").enter
+    assert_match @exp[:rgx], res
+  end
+
+  def test_output_and_enter2
+    res = @inst.output("*idn?\r\n \r\r\r\r;;\n;;\r\n\n").enter
+    assert_match @exp[:rgx], res
+  end
+
+  def test_output_and_enter3
+    @inst << "*idn?"
+    res = "" # @inst.enter
+    @inst >> res
+    assert_match @exp[:rgx], res
+  end
+
+  def test_error_message0
+    assert_equal NO_ERROR, @inst.errstr(0)
+  end
+
+  def test_error_message1
+    assert @inst.errstr(15)
+  end
+
+  def test_error_message2
+    assert_equal nil, @inst.errstr
+  end
+
+  def test_error_message3
+    error_message = ''
+
+    @inst.on_error { |err| error_message = err[1] }
+
+    @inst.raise_timeout
+
+    assert_equal TIMEOUT_OCCURRED, error_message
+  end
+
+  def test_error_message4
+    error_message = ''
+
+    @inst.on_error { |num, msg| error_message = msg }
+
+    @inst.raise_timeout
+
+    assert_equal TIMEOUT_OCCURRED, error_message
+  end
+
+  def test_error_close0
+    @inst.close
+    err = assert_exception(SICL::Error) { @inst.close }
+
+    assert_equal INVALID_INST, err.message
+  end
+
+  def test_error_close1
+    @inst.close
+    err = assert_exception(SICL::Error) { @inst.close }
+
+    assert_equal INVALID_INST, err.message
+  end
+
+  def test_error_timeout0
+    time_limit = 10000
+
+    @inst.timeout = time_limit
+
+    assert_equal time_limit, @inst.timeout
+  end
+
+  def test_error_timeout1
+    err = assert_exception(SICL::Error) {
+      @inst.raise_timeout
+    }
+
+    assert_equal TIMEOUT_OCCURRED, err.message
+  end
+
+  def test_error_timeout2
+    @inst.on_error = lambda {}
+
+    @inst.raise_timeout
+
+    assert true
+  end
+
+  def test_error_timeout3
+    @inst.on_error = lambda {}
+    @inst.on_error = nil
+
+    err = assert_exception(SICL::Error) {
+      @inst.raise_timeout
+    }
+
+    assert_equal TIMEOUT_OCCURRED, err.message
+  end
+
+  def test_error_timeout4
+    @inst.on_error {}
+
+    @inst.raise_timeout
+
+    assert true
+  end
+
+  def test_abort
+    assert @inst.abort if @@address =~ /^[gh]pib/ # gpib only
+  end
+
+  def test_clear
+    assert @inst.clear
+  end
+
+  def test_spoll
+    assert @inst.spoll
+  end
+
+  def test_local
+    assert @inst.local
+  end
+
+  def test_remote
+    assert @inst.remote
+  end
+
+  def test_flush0
+    assert @inst.flush
+  end
+
+  def test_flush1
+    assert @inst.flush(SICL::BUF_DISCARD_READ | SICL::BUF_DISCARD_WRITE)
+  end
+
+  def test_addr
+    assert_equal @inst.addr, @@address
+  end
+
+  def test_addr
+    assert_equal @inst.address, @@address
+  end
+
+  def test_termchr0
+    assert @inst.termchr = 0x20
+    assert_equal @inst.termchr, 0x20
+  end
+
+  def test_termchr1
+    assert @inst.termchr = " "[0]
+    assert_equal @inst.termchr, 0x20
+  end
+
+end
+
+################################################################################
+# MAIN ROUTINE
+################################################################################
+
+if $0 == __FILE__ then
+  RUNIT::CUI::TestRunner.run(TestSicl.suite(address))
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: sicl
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-13 00:00:00 +09:00
+summary: Agilent SICL API module for Ruby.
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: SICL/Ruby is SICL(Standard Instrument Control Library) API module for Ruby. SICL is part of the Agilent IO Libraries Suite product. SICL/Ruby gives you a capability to control your instruments via GPIB, USB, and LAN.
+autorequire: sicl
+default_executable: ext/extconf.rb
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: []
+
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- ext/sicl.c
+- ext/extconf.rb
+- test/test_sicl.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/extconf.rb
+requirements: []
+
+dependencies: []
+