rb_scope 2.0.2 → 2.0.4

data/README

@@ -0,0 +1,69 @@
+##
+ #              rb_scope
+ #
+ #     ( C2Ruby wrapper to NI-Scope drivers )
+ #    
+ #  version     2.0.4
+ #  author      hugo benichi
+ #  email       hugo.benichi@m4x.org
+ #  copyright   2012 hugo benichi
+ #  
+ #  reproduction 
+ #  
+ #    You can use this code without restriction if you mention my name in your project.
+ #    Other than that, you can redistribute and/or modify without restriction.
+ #  
+ #  description 
+ #  
+ #    A Ruby layer wrapping around C calls to the NI-Scope drivers.
+ #    Most C data manipulation and C calls are done through the FFI gems.
+ #	  In addition a few C methods are provided for improved efficiency when handling data
+ #
+ #  installation
+ #
+ #    gem install ni_scope-x.y.z.gem
+ #
+ #  usage
+ #
+ #    refer to rb_scope/test/test_rb_scope.rb
+ #
+ #  binaries
+ #    
+ #    the gem comes with precompiled 32bits libraries which should run on
+ #    Windows 32/64 bits without issues if your niScope drivers are
+ #    installed correctly
+ #
+ #    If necessary, the source files and script files to produce the binaries
+ #    are included with this gem, in rb_scope/ext/
+ #
+ #    Two binary dlls are required 
+ #    Because of a recent change in the NiScope drivers, it is now necesaary to use
+ #    MSVS cl and link to compiles them (it should be theoretically possible with mingw
+ #    but I have better things to do). To be able to compile the project on your PC
+ #    you should install Visual Studio C++ Express and use the VS developper prompt
+ #    which automatically configures your %PATH% variable and allows you to use MSVS
+ #    compiler and linker.
+ #
+ #    If everything is fine you can just compile fetch.dll and rb_scope.dll with rake
+ #    Run at the gem root directory the commands
+ #      rake dll_fetch
+ #      rake dll_rb_scope
+ #    
+ #    My scripts assume that you have a normal NiScope driver installation when looking 
+ #    for header files from NI. In the event these hardcoded paths are not correct, you
+ #    should edit rakefile.rb and provides paths to headers and to static libraries .lib
+ #
+ #    Expected path of the necessary header files and library:
+ #
+ #     niScope.h, ivi.h, iviScope.h
+ #       C:\Program Files (x86)\IVI Foundation\IVI\Include
+ #
+ #     visa.h, visatype.h, vpptype.h
+ #       C:\Program Files (x86)\IVI Foundation\VISA\WinNT\include
+ #
+ #     niScope.lib
+ #       C:\Program Files (x86)\IVI Foundation\IVI\Lib\msc
+ #       C:\Program Files (x86)\IVI Foundation\IVI\Lib_x64\msc
+ #       C:\Program Files (x86)\IVI Foundation\VISA\WinNT\Lib\msc
+ #       C:\Program Files (x86)\IVI Foundation\VISA\WinNT\Lib_x64\msc
+ #

data/ext/rb_scope/fetching/fetch.c

@@ -1,10 +1,11 @@
-
 #include  <stdio.h>
 #include  <stdlib.h>
 #include  "fetch.h"
 #include 	"niScope.h" 
 
-#define   prompt(MSG, ...)    printf("RbScope::Fetching::fetch.c >> " MSG, __VA_ARGS__)
+
+#define   prompt(MSG, ...)    printf("RbScope::Fetching >> " MSG, __VA_ARGS__)
+
 
   typedef   
     struct niScope_wfmInfo 
@@ -23,54 +24,45 @@ DLL int fetch(
   int             frm_chk   = parameters-> frm_chk;
   double          timeout   = parameters-> timeout;
   
-  char*           buff0     = NULL;
-  char*           buff1     = NULL;
-  buffer_address  buf_chan0 = parameters-> chan0;
-  buffer_address  buf_chan1 = parameters-> chan1;
-  void*           context0  = parameters-> chan0_context;
-  void*           context1  = parameters-> chan1_context;
+  char*           buf       = NULL;
+  buffer_address  buf_get   = parameters-> buffer_get;
+  void*           context   = parameters-> context;
   error_handler   err_clbck = parameters-> err_clbck;
    
-  wfm_info  frm_inf;
-  wfm_info *frm_inf_p = &frm_inf;
- 
-  int i, rez, records_done;  
+  #define err_check(ret_code)  do {\
+                                  int err_check_local_err_code = ret_code;\
+                                  if( err_check_local_err_code < 0)\
+                                  {\
+                                    if (err_clbck)\
+                                      err_clbck( err_check_local_err_code );\
+                                    prompt( "early return from error\n");\
+                                    niScope_Abort(session);\
+                                    return -1;\
+                                  }\
+                                } while (0)
+                                
+  wfm_info *frm_inf_p = malloc( sizeof(wfm_info) * 2 * frm_chk );
+  char* loc_buffer = malloc( 2 * frm_chk * frm_siz * sizeof(char)  ); 
 
-  rez = niScope_SetAttributeViBoolean(session, VI_NULL, NISCOPE_ATTR_ALLOW_MORE_RECORDS_THAN_MEMORY, 1); // maybe have to move this before horizontal configuration
-  if( rez < 0) err_clbck(rez);
-  rez = niScope_SetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_HORZ_RECORD_LENGTH,  frm_siz);
-  if( rez < 0) err_clbck(rez);
-  rez = niScope_SetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_HORZ_NUM_RECORDS,    frm_tot);
-  if( rez < 0) err_clbck(rez);
-  rez = niScope_SetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_FETCH_NUM_RECORDS,   frm_chk);
-  if( rez < 0) err_clbck(rez);
-
-  prompt("starting fetching on %s\n", address);  
+  int i, rez, records_done;  
+  
+  prompt("starting fetching on %s\n record length %i  |  record tot num %i  |  chunk %i\n", address, frm_siz, frm_tot, frm_chk);  
   for (i = 0; i < frm_tot; i += frm_chk) 
-  {
-    
-    rez = niScope_SetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_FETCH_RECORD_NUMBER, i);    
-    
-    if( rez < 0) err_clbck(rez);
-    if (buf_chan0 && (buff0 = buf_chan0(context0)) )   /* this call can block ! */
-      rez = niScope_FetchBinary8(session, "0", timeout, frm_siz, buff0, frm_inf_p);  
-      
-    if( rez < 0) err_clbck(rez);
-    if (buf_chan1 && (buff1 = buf_chan1(context1)) )    /* this call can block ! */
-      rez = niScope_FetchBinary8(session, "1", timeout, frm_siz, buff1, frm_inf_p);      
-           
-    if( rez < 0) err_clbck(rez);
-    
-    rez = niScope_GetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_RECORDS_DONE, &records_done);    
-    if( rez < 0) err_clbck(rez);
-    prompt("%s, frames fetched #%i  |  measured #%i  |  left %i\n", address, i, records_done, records_done - i);
+  { 
+    err_check( niScope_SetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_FETCH_RECORD_NUMBER, i) );
+    if (buf_get && !(buf = buf_get(context)) ) buf = loc_buffer;
+    err_check( niScope_FetchBinary8(session, "0,1", timeout, frm_siz, buf, frm_inf_p) );
+    err_check( niScope_GetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_RECORDS_DONE, &records_done) );
+    prompt("%s, frames fetched #%i | measured #%i | in dev mem %i\n", address, i, records_done, records_done - i);
   }
-
-  rez = niScope_GetAttributeViInt32(session, VI_NULL, NISCOPE_ATTR_RECORDS_DONE, &records_done);
-  if( rez < 0) err_clbck(rez);
   
-  prompt("%s, total frames measured per channel: %i\n", address, records_done);
+  free(loc_buffer);
   
   return records_done;
   
-}
+  #undef err_check
+  
+}
+
+
+#undef prompt

data/ext/rb_scope/fetching/fetch.h

@@ -20,10 +20,8 @@
     {
 	    char*				      address;        // physical address of the device
       error_handler     err_clbck;      // ruby callback to manage errors
-      buffer_address    chan0;          // return the address of the next 
-      buffer_address    chan1;          //   output buffer for chan0/1
-      void*             chan0_context;  // context for the buffer_address functions
-      void*             chan1_context;  // one per buffer
+      buffer_address    buffer_get;     // return the address of the next 
+      void*             context;        // context for the buffer_address functions
       double            timeout;        // in sec; -1 = infinite     
       int               frm_siz;        // numbr of data points per one frame
       int               frm_tot;        // total number of frm to fetch, per channels all chans one acq

data/lib/rb_scope.rb

@@ -17,8 +17,6 @@
 
 # main namespace module which encapsulates the helper methods and wrappring API calls
 module RbScope
-  
-  # <TO_DO> all addressedd from conf file / NiScope to auto-detect them ?
 
   class << self
 
@@ -29,6 +27,7 @@ module RbScope
 
   end
 
+  # load every required components
   [
     'rb_scope/api',
     'rb_scope/fetch',

data/lib/rb_scope/api.rb

@@ -1,10 +1,43 @@
 module RbScope
 
+  # This module acts as the Ruby interface to the C API.
+  # It loads the niScope dll library and links itself to the dll functions.
+  # It also loads all the macro constants defined in niScope.h for easier
+  # scripting of the digitizer devices from Ruby.
   module API
 
-    require 'rb_scope/api/niScope_api'    
+    require 'ffi'
+    require 'rb_scope/api/niScope_template'
     require 'rb_scope/api/niScope_values'
 
+    begin
+      extend FFI::Library
+      ffi_lib $LOAD_PATH.map{ |path| path+"/rb_scope/rb_scope.dll"}    
+      Template.each{ |sig| 
+        attach_function(  
+          sig[0].to_s.sub("niScope", "rbScope").to_sym, 
+          sig[1].map{|t| Types[:ruby][t] || t }, 
+          sig[2] 
+        )     
+      }
+    rescue
+      RbScope::prompt "could not load rb_scope.dll library"
+    end
+    
+    class << self
+      def handle_error address, visa_id, err_code, &block
+        buf1 = FFI::MemoryPointer.new :char, 1024
+        buf2 = FFI::MemoryPointer.new :char, 1024  
+        rbScope_errorHandler(visa_id, err_code, buf1, buf2)
+        puts  "RbScope error for session id %s / address %i:" % [address, visa_id],
+              "  source:  %s" % buf1.read_string(),
+              "  message: %s" % buf2.read_string()
+        #abord acquisition 
+        #close ses
+        block.call if block
+      end
+    end
+    
   end
   
 end

data/lib/rb_scope/api/niScope_values.rb

@@ -11,7 +11,7 @@ module RbScope
 
       Hash.new.tap{ |pairs|   
         File.open(File.dirname(__FILE__) + '/niScope_pairs.const', 'r').readlines.tap do |lines|
-          pairs[lines.shift] = lines.shift until lines.empty? #good 2 shift order
+          pairs[lines.shift] = lines.shift until lines.empty? # good 2 shift order
         end     
       }.each do |k,v|
         begin

data/lib/rb_scope/fetch.rb

@@ -1,25 +1,26 @@
 module RbScope
 
   module Fetch
+  
+    WfmInfoSize = 7 * 8 + 4
 
     require 'ffi'
     extend FFI::Library
     
-    #begin
+    begin
       ffi_lib $LOAD_PATH.map{ |path| path+"/rb_scope/fetch.dll"}
       attach_function :fetch, [:pointer], :int32, :blocking => true
-    #rescue
-    #  RbScope::prompt "could not load fetch.dll library"
-    #end
+    rescue
+      RbScope::prompt "could not load fetch.dll library"
+    end
     
     # simple Struct wrapper to pass information to fetch.c/fetch()
-    class Helper < FFI::ManagedStruct      
+    # no internal memory allocation so no need to use ManagedStruct
+    class Helper < FFI::Struct      
       layout  :address,   :pointer,
               :error,     :pointer,
-              :buff0,     :pointer,
-              :buff1,     :pointer,
-              :context0,  :pointer,
-              :context1,  :pointer,
+              :buf_get,   :pointer,
+              :context,   :pointer,
               :timeout,   :double,
               :points,    :int32,     #also frn_siz
               :records,   :int32,     #also frm_tot
@@ -27,11 +28,6 @@ module RbScope
               :session,   :uint32
 
       Default = {
-        error:    nil,
-        buff0:    nil,
-        buff1:    nil,
-        context0: nil,
-        context1: nil,
         timeout:  10.0,
         records:  1,
         chunk:    1,
@@ -44,25 +40,66 @@ module RbScope
   class Session
 
     def run param, &block 
+      self[:ALLOW_MORE_RECORDS_THAN_MEMORY,:bool] = 1
+      self[:HORZ_NUM_RECORDS,:int]                = param[:records] # number of records to fetch
+      self[:FETCH_NUM_RECORDS,:int]               = param[:chunk]   # number of records to fetch per call to Fetch
+      self.acquire                                                  # starts acquisition
+      block.call if block                                           # call pre-fetching block if necessary
+start = Time.new      
+      Fetch::fetch  Fetch::Helper.new.tap{ |h|
+        Fetch::Helper::Default.each_pair{ |k,v| h[k] = param[k] || v }  # params or use default   
+        h[:address] = FFI::MemoryPointer.from_string @address
+        h[:session] = @visa_id      
+        h[:points]  = @points     
+        h[:buf_get], h[:context] = param[:buf]
+        h[:error] = param[:error] || FFI::Function.new(:void,[:int32]){ |code| self.check code }
+      }
+puts "elapsed %ssec" % (Time.new - start)
+      self.stop
+      self 
+    end
     
-      h = Helper.new
-      Helper::Default.each_pair{ |k,v| h[k] = param[k] || v }  #configure from parameters or ortherwise use default 
+    # does not work at the moment
+    def run_ruby param, &block 
+      records, chunk = param[:records], param[:chunk]
+      wfm_info_p = FFI::MemoryPointer.new :int32, 2 * chunk * Fetch::WfmInfoSize
+      self[:ALLOW_MORE_RECORDS_THAN_MEMORY,:bool] = 1
+      self[:HORZ_NUM_RECORDS,:int]                = records # number of records to fetch
+      self[:FETCH_NUM_RECORDS,:int]               = chunk   # number of records to fetch per call to Fetch
+      self.acquire                                          # starts acquisition
+      block.call if block                                   # call pre-fetching block if necessary
       
-      h[:address] = FFI::MemoryPointer.from_string @address
-      h[:session] = FFI::MemoryPointer.from_string @visa_id      
-      h[:points]  = @points
-      begin
-      h[:buff0], h[:context0] = param[:chan0].call, param[:chan0].context if param[:chan0]
-      h[:buff1], h[:context1] = param[:chan1].call, param[:chan1].context if param[:chan1]
-      rescue
-        RbScope::prompt "could not configure channels output buffers"
+start = Time.new    
+      i = 0
+      while i < records
+        self[:FETCH_RECORD_NUMBER, :int] = i
+        check API::niScope_FetchBinary8 @visa_id, "0,1", 10.0, @points, param[:buf].call, wfm_info_p
+        done = self[:RECORDS_DONE, :int]
+        puts "RbScope::Fetching (ruby) >> %s, frames fetched #%i | measured #%i | in dev mem %i" % [
+          @address,
+          i,
+          done,
+          done - i,
+        ]
+        i += chunk
       end
+puts "elapsed %ssec" % (Time.new - start)
+
+      self.stop
+      self 
+    end
     
-      self.acquire
-      block.call if block   # call pre-fetching block if necessary
-      Fetch::fetch  h
-      self
-      
+    def waveform channel = "0"
+      wfm_info_p = FFI::MemoryPointer.new :int32, 2 * Fetch::WfmInfoSize
+      buffer     = FFI::MemoryPointer.new :char, 2 * @points      
+      self[:ALLOW_MORE_RECORDS_THAN_MEMORY,:bool] = 1
+      self[:HORZ_NUM_RECORDS,:int]                = 1 
+      self[:FETCH_NUM_RECORDS,:int]               = 1
+      self.acquire               
+      self[:FETCH_RECORD_NUMBER, :int] = 0
+      check API::niScope_FetchBinary8 @visa_id, channel, 10.0, @points, buffer, wfm_info_p
+      self.stop
+      buffer.get_array_of_char 0, 2 * @points 
     end
   
   end

data/lib/rb_scope/session.rb

@@ -2,35 +2,38 @@ module RbScope
   
   # Helper class to encapsulate data and state relative to a device Session
   # This is the main class that clients instantiate to use the gem.
-  # <TO_DO> 1) implement errors 2) attributes setters/getters
-  #
-  # typical usage: RbScope::Session.new("mydevice").configure parameters
-  # 
   class Session
 
     attr_reader :address, :visa_id, :status
 
-    #starts a new connection
+    # starts a new connection
     def initialize address, &block
       @address = address      
       session_p = FFI::MemoryPointer.new :pointer, 1      
-      @status = API::rbScope_init address, 1, 1, session_p
-      #handle error if @status < 0
-      @visa_id = session_p.read_pointer.read_uint32
-      prompt "session ##{@visa_id} for device #{@address} initalized with status #{@status}"
+      check API::rbScope_init address, 1, 1, session_p
+      @visa_id = session_p.read_uint32
+      RbScope::prompt "session #%i for device %s initalized with status %i" % [@visa_id, @address, @status]
+      check API::rbScope_ConfigureAcquisition @visa_id, API::Values::NISCOPE_VAL_NORMAL     
       self.instance_eval &block if block
       self
     end
   
     # cleanup method called by the garbage collector
     def self.release session
-      if API::rbScope_close(session.visa_id) < 0
-        #handle error
-      end
+      session.check API::rbScope_close(session.visa_id)
     end
     
-    require 'rb_scope/session_methods'
-    require 'rb_scope/session_attributes'   
+    # store the NiScope return code into @status 
+    # and check if the return code is an error code
+    #   if error, call error_handler
+    def check name = nil, code
+      @status = code
+      puts "return code for %s: %i" % [name, @status] if name      
+      API::handle_error @address, @visa_id, @status if @status < 0
+    end
+    
+    require 'rb_scope/session/method_dispatch'
+    require 'rb_scope/session/attributes'   
     
   end
 

data/lib/rb_scope/session/attributes.rb

@@ -0,0 +1,78 @@
+module RbScope
+
+  class Session 
+  
+    Attribute_Types = {
+      int:      "Int32",
+      int32:    "Int32",     
+      bool:     "Boolean",
+      uint16:   "Boolean",
+      boolean:  "Boolean",     
+      real64:   "Real64",
+      double:   "Real64",
+      float:    "Real64",
+      string:   "String",
+      pchar:    "String"
+    }
+
+    Pointer_Types = [
+      int:      :int32,
+      int32:    :int32,     
+      bool:     :uint16,
+      uint16:   :uint16,
+      boolean:  :uint16,     
+      real64:   :double,
+      double:   :double,
+      float:    :double,
+      string:   :string,
+      pchar:    :string
+    ]
+    
+    # gives the actual lengtt of one measured frame
+    def actual_points
+      p = FFI::MemoryPointer.new :int32, 1
+      check API::rbScope_ActualRecordLength( @visa_id, p)
+      p.read_int32
+    end
+
+    # gives the actual number of recorded waveform
+    def actual_records chan = "0,1"
+      p = FFI::MemoryPointer.new :int32, 1
+      check API::rbScope_ActualNumWfms( @visa_id, chan, p)
+      p.read_int32    
+    end
+    
+    # attributes getter
+    def [] attrb_name = nil, attrb_type = nil
+      if attrb_name && attrb_type
+        getter   = "rbScope_GetAttributeVi%s" % Attribute_Types[attrb_type]
+        attrb_id = API::Values.const_get "NISCOPE_ATTR_#{attrb_name}".to_sym
+        store_t = Pointer_Types[attrb_type]
+        store   = FFI::MemoryPointer.new store_t, case store_t
+          when :string then 128
+          when :double then 2
+          else 1
+        end
+        check API.send setter, @visa_id, nil, attrb_name, store      
+        case store_t
+          when :int32  then store.read_int32
+          when :uint16 then store.read_uint16
+          when :double then store.read_double
+          when :string then store.read_string 
+        end
+      end
+    end
+
+    # attributes setter    
+    def []= attrb_name = nil, attrb_type = nil, attrb_value
+      if attrb_name && attrb_type    
+        setter   = "rbScope_SetAttributeVi#{Attribute_Types[attrb_type]}".to_sym
+        attrb_id = API::Values.const_get "NISCOPE_ATTR_#{attrb_name}".to_sym
+        check API.send setter, @visa_id, nil, attrb_id, attrb_value
+        self
+      end    
+    end
+    
+  end
+  
+end

data/lib/rb_scope/session/method_dispatch.rb

@@ -0,0 +1,111 @@
+module RbScope
+
+  class Session 
+
+    # This table defines the how the methods from the niScope dll are hooked to instances
+    # of the Session class.
+    # Arguments are passed to each methods with an Hash and through their Hash keys
+    Methods = [
+      [:calibrate,  "CalSelfCalibrate", ["0,1", 0]],
+      [:acquire,    "InitiateAcquisition", []],
+      [:stop,       "Abort", []],
+
+      [:trig_now,   "ConfigureTriggerImmediate", []],
+      [:trig_digi,
+        "ConfigureTriggerDigital",
+        [API::Values::NISCOPE_VAL_EXTERNAL, :slope, :deadtime, 0.0]],
+      [:trig_edge,
+        "ConfigureTriggerEdge",
+        [API::Values::NISCOPE_VAL_EXTERNAL, :level, :slope, :coupling, :deadtime, 0.0]],
+
+      [:vertical,   "ConfigureVertical",
+        [:channel, :range, 0.0, :coupling, 1.0, 1]],
+      [:channel,    "ConfigureChanCharacteristics",
+        [:channel, :impedance, :bandwidth]],
+      [:horizontal, "ConfigureHorizontalTiming",
+        [:rate, :points, :position, :records, 1]],      
+    ]
+
+    # default values for parameters of configuration functions
+    Defaults = {
+      deadtime:         0.0,
+      slope:            API::Values::NISCOPE_VAL_POSITIVE,
+      trig_coupling:    API::Values::NISCOPE_VAL_DC,
+      level:            0.5,
+      position:         0.5,
+      coupling:         API::Values::NISCOPE_VAL_DC,
+      impedance:        API::Values::NISCOPE_VAL_1_MEG_OHM,
+      #impedance:        50.0,
+      bandwidth:        API::Values::NISCOPE_VAL_BANDWIDTH_FULL,
+      rate:             100000000.0,
+      points:           1000,
+      records:          1000,
+      range:            1.0,
+    }
+    
+    # this block of code does the actual patching
+    # for each method declared in Methods, 
+    # it deynamically defines a dispatch method
+    # which sets arguments according to the info found in Methods
+    #   if a symbol is found
+    #     the dispatcher looks for the user provided hash
+    #     and tries to get a value
+    #     if it is null, it used the defaults value
+    #   if not a symbol, then the hardcoded value is used
+    Methods.each do |sig|   
+      define_method(sig[0]) do |args=nil|
+        meth = "rbScope_#{sig[1]}".to_sym           # generate the method name found in RbScope::API
+        args_chain  = [@visa_id] +                  # first arg is always the session Id number
+                      sig[2].map{ |x|
+                        if x.is_a? Symbol           # if x is a symbol, check for user provided value
+                          args[x] || Defaults[x]    # if no value use default
+                        else
+                          x                         # else use the hardcoded value
+                        end
+                      }
+        check API::send meth, *args_chain           # finally dispatch the method call to RbScope::API
+        self
+      end
+    end
+
+    # helper method for horizontal configuration    
+    alias_method :horizontal_pre, :horizontal
+    def horizontal param
+      @points = param[:points] || Defaults[:points]
+      horizontal_pre param
+    end
+    
+    # helper method for vertical configuration
+    alias_method :channel_pre, :channel
+    def channel i, param
+      param.clone.tap{ |hash| 
+          hash[:channel] = i.to_s 
+          self.channel_pre hash
+          self.vertical    hash
+      }
+    end
+    
+    # helper method for trigger configuration
+    def trigger param
+      case param[:type] || :edge
+        when :edge then self.trig_edge param
+        when :digi then self.trig_digi param
+        when :now  then self.trig_now  param 
+        when :soft then self.trig_now  param      
+      end
+    end
+    
+    # 1-in-5 configuration methods with the convention that there is a :channel key 
+    # which points to an array of subhash for both channels which looks like:
+    #   parameters = {:channel [ {range: 0.1, chan_impendance: 50, ... }, {...} ]}
+    def configure parameters
+      self.horizontal parameters
+      parameters[:channel].each_with_index{ |chan_param, i|    
+        self.channel i, param
+      } if parameters[:channel]
+      self.trigger parameters
+    end
+  
+  end
+  
+end

data/rakefile.rb

@@ -9,7 +9,7 @@ name = 'rb_scope'
   end
 
   task :gem_install => :gem_build do
-    gemfile = Dir.new("./").entries.select{ |f| f =~ /rb_scope-[\d]+\.[\d]+\.[\d]+.gem/ }[0]
+    gemfile = Dir.new("./").entries.select{ |f| f =~ /rb_scope-[\d]+\.[\d]+\.[\d]+.gem/ }.sort[-1]
     sh "gem install %s" % gemfile
   end
 
@@ -46,7 +46,7 @@ end
   task :set_path do
     puts "you might need to run the command prompt as Administrator"
     #ask for VC env var batch script
-      sh '"C:\Program Files (x86)\MVS10.0\VC\vcvarsall.bat"'
+      #sh '"C:\Program Files (x86)\MVS10.0\VC\vcvarsall.bat"'
       #ask for path to niScope.h
       #ask for path to ivi.h and visa.h
       path_include = '"C:\Program Files (x86)\IVI Foundation\VISA\WinNT\include"'

data/test/test_rb_scope.rb

@@ -1,3 +1,35 @@
-require "rb_scope"
+require "rb_scope"
+require "c_buffer"
 
-puts "ok"
+records = 10000
+points  = 1000
+chunk   = 1000
+buf_num = 32
+size    = 2 * chunk * points
+dc      = RbScope::API::Values::NISCOPE_VAL_DC
+megaohm = 50.0 #RbScope::API::Values::NISCOPE_VAL_1_MEG_OHM
+
+digitizer = RbScope::Session.new 'Dev1' do |d|
+  d.stop
+  d.horizontal(rate: 1E9, points: points, records: records, position: 0.5)
+  d.channel     0, { range: 0.1, coupling: dc, impedance: megaohm}
+  d.channel     1, { range: 0.1, coupling: dc, impedance: megaohm}
+  d.trigger( type: :edge, level: 0.5, coupling: dc)  
+end
+
+buffer     = CBuffer.new( path: "data.raw", chunk: size, length: buf_num)
+buffer_get = FFI::Function.new(:pointer, [:pointer]){ |v| buffer.input }
+
+buffer.output
+
+digitizer.run( 
+  records:  records,
+  chunk:    chunk,
+  buf:      [buffer_get, nil]
+)
+
+buffer.stop
+
+RbScope::Session.release digitizer
+
+puts "ok"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_scope
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-15 00:00:00.000000000 Z
+date: 2012-07-09 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby layer wrapping around C calls to the NI-Scope drivers based on
   the ffi gem api
@@ -18,32 +18,32 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/rb_scope/api/niScope_api.rb
 - lib/rb_scope/api/niScope_template.rb
 - lib/rb_scope/api/niScope_values.rb
-- lib/rb_scope/api.rb
+- lib/rb_scope/session/attributes.rb
+- lib/rb_scope/session/method_dispatch.rb
 - lib/rb_scope/fetch.rb
 - lib/rb_scope/session.rb
-- lib/rb_scope/session_attributes.rb
-- lib/rb_scope/session_methods.rb
+- lib/rb_scope/api.rb
 - lib/rb_scope.rb
 - lib/rb_scope/api/niScope_pairs.const
 - lib/rb_scope/fetch.dll
 - lib/rb_scope/rb_scope.dll
-- lib/rb_scope/fetch.lib
-- lib/rb_scope/rb_scope.lib
-- ext/rb_scope/fetching/fetch.c
 - ext/rb_scope/wrapper.c
+- ext/rb_scope/fetching/fetch.c
 - ext/rb_scope/fetching/fetch.h
 - ext/rb_scope/example.rb
-- ext/rb_scope/generators/extract_names.rb
 - ext/rb_scope/generators/extract_pairs.rb
 - ext/rb_scope/generators/wrapper_generator.rb
+- ext/rb_scope/generators/extract_names.rb
 - ext/rb_scope/generators/extract_all.sh
+- ext/rb_scope/fetch.dll
+- ext/rb_scope/rb_scope.dll
+- ext/rb_scope/rb_scope.lib
+- ext/rb_scope/fetch.lib
 - test/test_rb_scope.rb
-- compile_cl.bat
 - rakefile.rb
-- README.txt
+- README
 homepage: http://github.com/hugobenichi/rb_scope
 licenses: []
 post_install_message: 
@@ -64,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.16
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: C2Ruby wrapper to NI-Scope drivers

data/README.txt

@@ -1,26 +0,0 @@
-##
- #              ni_scope
- #
- #     ( C2Ruby wrapper to NI-Scope drivers )
- #    
- #  version     2.0.1
- #  author      hugo benichi
- #  email       hugo.benichi@m4x.org
- #  copyright   2012 hugo benichi
- #  
- #  reproduction 
- #  
- #    You can use this code without restriction if you mention my name in your project.
- #    Other than that, you can redistribute and/or modify without restriction.
- #  
- #  description 
- #  
- #    A Ruby layer wrapping around C calls to the NI-Scope drivers.
- #    Most C data manipulation and C calls are done through the FFI gems.
- #	  In addition a few C methods are provided for improved efficiency when handling data
- #
- #  installation
- #
- #    gem install ni_scope-x.y.z.gem
- #
- ##

data/compile_cl.bat

@@ -1,17 +0,0 @@
-
-::  Bat script for compilation of the rb_scope.dll using MSVS cl and link.
-::  This script has been automatically generated by rake from the template in rakefile.rb.
-::
-::  author      hugo benichi
-::  email       hugo.benichi@gmail.com
-::  copyright   2012 hugo benichi
-
-  call "C:\Program Files (x86)\MVS10.0\VC\vcvarsall.bat"
-
-  call ruby -Ilib ext\ni_scope\wrapper_generator.rb > ext\ni_scope\wrapper.c
-
-  call cl -c .\ext\ni_scope\wrapper.c -I"C:\Program Files (x86)\IVI Foundation\VISA\WinNT\include"  
-
-  call link /DLL /OUT:ext\ni_scope\rb_scope.dll wrapper.obj "C:\Program Files (x86)\IVI Foundation\VISA\WinNT\Lib\msc\niScope.lib" 
-  
-  

data/lib/rb_scope/api/niScope_api.rb

@@ -1,31 +0,0 @@
-module RbScope
-
-  # This module acts as the Ruby interface to the C API.
-  # It loads the niScope dll library and links itself to the dll functions.
-  # It also loads all the macro constants defined in niScope.h for easier
-  # scripting of the digitizer devices from Ruby.
-  module API
-
-    require 'ffi'
-    require 'rb_scope/api/niScope_template'
-    require 'rb_scope/api/niScope_values'
-    
-    extend FFI::Library
-    
-    #begin
-      ffi_lib $LOAD_PATH.map{ |path| path+"/rb_scope/rb_scope.dll"}    
-      Template.each{ |sig| 
-      puts sig
-        attach_function(  
-          sig[0].to_s.sub("niScope", "rbScope").to_sym, 
-          sig[1].map{|t| Types[:ruby][t] || t }, 
-          sig[2] 
-        )     
-      }
-    #rescue
-    #  RbScope::prompt "could not load rb_scope.dll library"
-    #end
-
-  end
-  
-end

data/lib/rb_scope/session_attributes.rb

@@ -1,21 +0,0 @@
-module RbScope
-
-  class Session 
-
-    Attribute = [
-    
-    
-    ]
-  
-    Getters = [
-    
-    
-    ]   
-    
-    def define_attribute name, id, type    
-      #nantoka    
-    end
-  
-  end
-  
-end

data/lib/rb_scope/session_methods.rb

@@ -1,82 +0,0 @@
-module RbScope
-
-  class Session 
-
-    # This table defines the how the methods from the niScope dll are hooked to instances
-    # of the Session class.
-    # Arguments are passed to each methods with an Hash and through their Hash keys
-    Methods = [
-      [:calibrate,  "CalSelfCalibrate", ["0,1", 0]],
-      [:acquire,    "InitiateAcquisition", []],
-      [:stop,       "Abort", []],
-
-      [:trig_now,   "ConfigureTriggerImmediate", []],
-      [:trig_digi,
-        "ConfigureTriggerDigital",
-        [API::Values::NISCOPE_VAL_EXTERNAL, :slope, :deadtime, 0.0]],
-      [:trig_edge,
-        "Configure_TriggerEdge",
-        [API::Values::NISCOPE_VAL_EXTERNAL, :trig_voltage, :slope, :trig_coupling, :deadtime, 0.0]],
-
-      [:vertical,   "ConfigureVertical",
-        [:channel, :range, 0.0, :coupling, 1.0, 1]],
-      [:channel,    "ConfigureChanCharacteristics",
-        [:channel, :impedance, :bandwidth]],
-      [:horizontal, "ConfigureHorizontalTiming",
-        [:rate, :points, :trig_reference, :records, 1]],      
-    ]
-    
-    #this block of code does the actual patching
-    Methods.each do |sig|   
-      define_method(sig[0]) do |*args|
-        meth = "rbScope_#{sig[1]}".to_sym           # generate the good method name found in RbScope::API
-        args_chain  = [@visa_id]                     # first arg is always the session Id number
-                    + sig[2].map{ |x|
-                      if x.is_a? Symbol             # if x is a symbol, check for user provided value
-                        args[x] || Defaults[x]      # if no value use default
-                      else
-                        x                           # else use the hardcoded value
-                      end
-                    }
-        @status = API::send meth, args_chain        # finally dispatch the method call to RbScope::API
-        #handle_error if rez < 0
-        self
-      end
-    end
-    
-    # 1-in-4 configuration methods with the convention that there is a :channel key 
-    # which points to an array of subhash for both channels which looks like:
-    #   parameters = {:channel [ {range: 0.1, chan_impendance: 50, ... }, {...} ]}
-    def configure parameters
-      @points = parameters[:points] || Defaults[:points]
-      self.horizontal parameters
-      parameters[:channel].each_with_index{ |p,i|
-        self.channel i.to_s, p
-      } if parameters[:channel]
-    end
-    
-    #shortcut for channel configuration
-    def channel chan, parameters
-      param = parameters.clone.tap{ |hash| hash[:channel] = chan }
-      [:channel, :vertical].each{ |meth| self.send meth, parame }
-    end
-      
-    # default values for parameters of configuration functions
-    Defaults = {
-      deadtime:         0.0,
-      slope:            API::Values::NISCOPE_VAL_POSITIVE,
-      trig_coupling:    API::Values::NISCOPE_VAL_DC,
-      trig_voltage:     0.5,
-      trig_reference:   0.5,
-      coupling:         API::Values::NISCOPE_VAL_AC,
-      impedance:        API::Values::NISCOPE_VAL_1_MEG_OHM,
-      bandwidth:        API::Values::NISCOPE_VAL_BANDWIDTH_FULL,
-      rate:             1000000,
-      points:           1000,
-      records:          1000,
-      range:            1.0,
-    }
-  
-  end
-  
-end