origen_link 0.4.2 → 0.4.3

data/lib/origen_link/server/pin.rb

@@ -1,218 +1,218 @@
-# OrigenLink::Server::Pin class manipulate input/output pins of the Udoo
-# using exported file objects.  If the pin is not exported, it
-# will be exported when a pin is initialized
-#
-
-module OrigenLink
-  module Server
-    # The server pin class is used to perform IO using the UDOO pins
-    class Pin
-      @@pin_setup = {
-        in:  'in',
-        out: 'out'
-      }
-
-      # True if this pin exists in /sys/class/gpio after export.  False otherwise.
-      attr_reader :gpio_valid
-      # This pin's vector data for the pattern cycle being executed
-      attr_accessor :pattern_data
-      # This pin's index in the vector data received from the plug-in app
-      attr_accessor :pattern_index
-      # This pin's response for the executing vector
-      attr_accessor :response
-
-      # Export the pin io files through the system and take control of the IO
-      #
-      # This method will execute system command
-      # "echo #{ionumber} > /sys/class/gpio/export"
-      # to create the IO file interface.  It will
-      # set the direction, initial pin state and initialize
-      # instance variables
-      #
-      # Receives
-      #  ionumber - required, value indicating the pin number (BCM IO number,
-      #             not the header pin number)
-      #  direction - optional, specifies the pin direction.  A pin is
-      #              initialized as an input if a direction isn't specified.
-      #
-      def initialize(ionumber, direction = :in)
-        @ionumber = Integer(ionumber)
-        @pin_dir_name = "#{Server.gpio_dir}/gpio#{@ionumber}/direction"
-        @pin_val_name = "#{Server.gpio_dir}/gpio#{@ionumber}/value"
-        if !File.exist?(@pin_dir_name)
-          system("echo #{@ionumber} > #{Server.gpio_dir}/export")
-          sleep 0.05
-          if $CHILD_STATUS == 0
-            @gpio_valid = true
-          else
-            @gpio_valid = false
-          end
-        else
-          @gpio_valid = true
-        end
-        if @gpio_valid
-          if File.writable?(@pin_dir_name)
-            @pin_dir_obj = File.open(@pin_dir_name, 'w')
-            update_direction(direction)
-          else
-            @gpio_valid = false
-            puts "#{@pin_dir_name} is not writable. Fix permissions or run as super user."
-          end
-          @pin_val_obj = File.open(@pin_val_name, 'r+') if @gpio_valid
-        end
-        @pattern_data = ''
-        @pattern_index = -1
-        @response = 'W'
-        @cycle_failure = false
-        @data_is_drive = false
-      end
-
-      # data_is_drive?
-      #   returns whether the current pattern data is drive
-      def data_is_drive?
-        @data_is_drive
-      end
-
-      # data_is_compare?
-      #   returns whether the current pattern data is compare
-      def data_is_compare?
-        !@data_is_drive
-      end
-
-      # cycle_failure
-      #   returns a boolean indicating pass/fail status of this pin
-      def cycle_failure
-        if @response == 'W'
-          true		# force failure if no operation performed
-        else
-          @cycle_failure
-        end
-      end
-
-      # load_pattern_data
-      #   Grab this pin's data character from the pattern data
-      def load_pattern_data(cycle)
-        if @pattern_index > -1
-          @pattern_data = cycle[@pattern_index]
-          @response = 'W'
-          @cycle_failure = false
-          if @pattern_data == '1' || @pattern_data == '0'
-            @data_is_drive = true
-          else
-            @data_is_drive = false
-          end
-        else
-          @gpio_valid = false
-        end
-      end
-
-      # process_event(event)
-      #   perform the requested pin operation and update the response (if required)
-      def process_event(operation, requested_action)
-        if operation == :drive
-          if data_is_drive?
-            if requested_action == 'data'
-              out(@pattern_data)
-              @response = @pattern_data
-            else
-              out(requested_action)
-            end # requested_action == 'data'
-          end # data_is_drive?
-        end # operation == :drive
-        if operation == :compare
-          if data_is_compare?
-            if requested_action == 'data'
-              case self.in
-                when '0'
-                  @cycle_failure = true if @pattern_data == 'H'
-                  if @pattern_data == 'X'
-                    @response = '.'
-                  else
-                    @response = 'L'
-                  end
-                # end of when '0'
-                when '1'
-                  @cycle_failure = true if @pattern_data == 'L'
-                  if @pattern_data == 'X'
-                    @response = '`'
-                  else
-                    @response = 'H'
-                  end
-                # end of when '1'
-                else
-                  @response = 'W'
-              end # case
-            end # requested_action == 'data'
-          end # data_is_compare?
-        end # operation == :compare
-      end
-
-      # Close the file IO objects associated with this pin
-      def destroy
-        if @gpio_valid
-          @pin_dir_obj.close
-          @pin_val_obj.close
-          # system("echo #{@ionumber} > /sys/class/gpio/unexport")
-          # puts "pin #{@ionumber} is no longer exported"
-        end
-      end
-
-      # Sets the output state of the pin.
-      #
-      # If the pin is setup as an input,
-      # the direction will first be changed to output.
-      #
-      def out(value)
-        if @gpio_valid
-          if @direction == :in
-            update_direction(:out)
-          end
-          @pin_val_obj.write(value)
-          @pin_val_obj.flush
-        end
-      end
-
-      # Reads and returns state of the pin.
-      #
-      # If the pin is setup as an output, the direction will first
-      # be changed to input.
-      #
-      def in
-        if @gpio_valid
-          if @direction == :out
-            update_direction(:in)
-          end
-          # below is original read - slow to reopen every time
-          # File.open(@pin_val_name, 'r') do |file|
-          #  file.read#.chomp
-          # end
-          # end original read
-          @pin_val_obj.pos = 0
-          @pin_val_obj.getc
-        end
-      end
-
-      # Sets the pin direction
-      #
-      # Receives:
-      #  direction - specifies the pin direction.  Input is default.
-      #
-      #  Valid direction values:
-      #    :in	-	input
-      #    :out	-	output
-      def update_direction(direction)
-        if @gpio_valid
-          @pin_dir_obj.pos = 0
-          @pin_dir_obj.write(@@pin_setup[direction])
-          @pin_dir_obj.flush
-          @direction = direction
-        end
-      end
-
-      # Returns 'OrigenLinPin' + io number
-      def to_s
-        'OrigenLinkPin' + @ionumber.to_s
-      end
-    end
-  end
-end
+# OrigenLink::Server::Pin class manipulate input/output pins of the Udoo
+# using exported file objects.  If the pin is not exported, it
+# will be exported when a pin is initialized
+#
+
+module OrigenLink
+  module Server
+    # The server pin class is used to perform IO using the UDOO pins
+    class Pin
+      @@pin_setup = {
+        in:  'in',
+        out: 'out'
+      }
+
+      # True if this pin exists in /sys/class/gpio after export.  False otherwise.
+      attr_reader :gpio_valid
+      # This pin's vector data for the pattern cycle being executed
+      attr_accessor :pattern_data
+      # This pin's index in the vector data received from the plug-in app
+      attr_accessor :pattern_index
+      # This pin's response for the executing vector
+      attr_accessor :response
+
+      # Export the pin io files through the system and take control of the IO
+      #
+      # This method will execute system command
+      # "echo #{ionumber} > /sys/class/gpio/export"
+      # to create the IO file interface.  It will
+      # set the direction, initial pin state and initialize
+      # instance variables
+      #
+      # Receives
+      #  ionumber - required, value indicating the pin number (BCM IO number,
+      #             not the header pin number)
+      #  direction - optional, specifies the pin direction.  A pin is
+      #              initialized as an input if a direction isn't specified.
+      #
+      def initialize(ionumber, direction = :in)
+        @ionumber = Integer(ionumber)
+        @pin_dir_name = "#{Server.gpio_dir}/gpio#{@ionumber}/direction"
+        @pin_val_name = "#{Server.gpio_dir}/gpio#{@ionumber}/value"
+        if !File.exist?(@pin_dir_name)
+          system("echo #{@ionumber} > #{Server.gpio_dir}/export")
+          sleep 0.05
+          if $CHILD_STATUS == 0
+            @gpio_valid = true
+          else
+            @gpio_valid = false
+          end
+        else
+          @gpio_valid = true
+        end
+        if @gpio_valid
+          if File.writable?(@pin_dir_name)
+            @pin_dir_obj = File.open(@pin_dir_name, 'w')
+            update_direction(direction)
+          else
+            @gpio_valid = false
+            puts "#{@pin_dir_name} is not writable. Fix permissions or run as super user."
+          end
+          @pin_val_obj = File.open(@pin_val_name, 'r+') if @gpio_valid
+        end
+        @pattern_data = ''
+        @pattern_index = -1
+        @response = 'W'
+        @cycle_failure = false
+        @data_is_drive = false
+      end
+
+      # data_is_drive?
+      #   returns whether the current pattern data is drive
+      def data_is_drive?
+        @data_is_drive
+      end
+
+      # data_is_compare?
+      #   returns whether the current pattern data is compare
+      def data_is_compare?
+        !@data_is_drive
+      end
+
+      # cycle_failure
+      #   returns a boolean indicating pass/fail status of this pin
+      def cycle_failure
+        if @response == 'W'
+          true		# force failure if no operation performed
+        else
+          @cycle_failure
+        end
+      end
+
+      # load_pattern_data
+      #   Grab this pin's data character from the pattern data
+      def load_pattern_data(cycle)
+        if @pattern_index > -1
+          @pattern_data = cycle[@pattern_index]
+          @response = 'W'
+          @cycle_failure = false
+          if @pattern_data == '1' || @pattern_data == '0'
+            @data_is_drive = true
+          else
+            @data_is_drive = false
+          end
+        else
+          @gpio_valid = false
+        end
+      end
+
+      # process_event(event)
+      #   perform the requested pin operation and update the response (if required)
+      def process_event(operation, requested_action)
+        if operation == :drive
+          if data_is_drive?
+            if requested_action == 'data'
+              out(@pattern_data)
+              @response = @pattern_data
+            else
+              out(requested_action)
+            end # requested_action == 'data'
+          end # data_is_drive?
+        end # operation == :drive
+        if operation == :compare
+          if data_is_compare?
+            if requested_action == 'data'
+              case self.in
+                when '0'
+                  @cycle_failure = true if @pattern_data == 'H'
+                  if @pattern_data == 'X'
+                    @response = '.'
+                  else
+                    @response = 'L'
+                  end
+                # end of when '0'
+                when '1'
+                  @cycle_failure = true if @pattern_data == 'L'
+                  if @pattern_data == 'X'
+                    @response = '`'
+                  else
+                    @response = 'H'
+                  end
+                # end of when '1'
+                else
+                  @response = 'W'
+              end # case
+            end # requested_action == 'data'
+          end # data_is_compare?
+        end # operation == :compare
+      end
+
+      # Close the file IO objects associated with this pin
+      def destroy
+        if @gpio_valid
+          @pin_dir_obj.close
+          @pin_val_obj.close
+          # system("echo #{@ionumber} > /sys/class/gpio/unexport")
+          # puts "pin #{@ionumber} is no longer exported"
+        end
+      end
+
+      # Sets the output state of the pin.
+      #
+      # If the pin is setup as an input,
+      # the direction will first be changed to output.
+      #
+      def out(value)
+        if @gpio_valid
+          if @direction == :in
+            update_direction(:out)
+          end
+          @pin_val_obj.write(value)
+          @pin_val_obj.flush
+        end
+      end
+
+      # Reads and returns state of the pin.
+      #
+      # If the pin is setup as an output, the direction will first
+      # be changed to input.
+      #
+      def in
+        if @gpio_valid
+          if @direction == :out
+            update_direction(:in)
+          end
+          # below is original read - slow to reopen every time
+          # File.open(@pin_val_name, 'r') do |file|
+          #  file.read#.chomp
+          # end
+          # end original read
+          @pin_val_obj.pos = 0
+          @pin_val_obj.getc
+        end
+      end
+
+      # Sets the pin direction
+      #
+      # Receives:
+      #  direction - specifies the pin direction.  Input is default.
+      #
+      #  Valid direction values:
+      #    :in	-	input
+      #    :out	-	output
+      def update_direction(direction)
+        if @gpio_valid
+          @pin_dir_obj.pos = 0
+          @pin_dir_obj.write(@@pin_setup[direction])
+          @pin_dir_obj.flush
+          @direction = direction
+        end
+      end
+
+      # Returns 'OrigenLinPin' + io number
+      def to_s
+        'OrigenLinkPin' + @ionumber.to_s
+      end
+    end
+  end
+end

data/lib/origen_link/server/sequencer.rb

@@ -1,469 +1,469 @@
-require 'origen_link/server/pin'
-
-##################################################
-# OrigenLink::Server::Sequencer Class
-#    Instance variables:
-#      pinmap: hash with ["pin name"] = pin object
-#      patternpinindex: hash with ["pin name"] =
-#        integer index into vector data
-#      patternpinorder: Array with pin names in
-#        the vector order
-#
-#    This class processes messages targeted for
-#    pin sequencer interface (vector pattern
-#    execution).
-#
-#    Supported messages:
-#      pin_assign (create pin mapping)
-#        ex: "pin_assign:tck,3,extal,23,tdo,5"
-#
-#      pin_patternorder (define vector pin order)
-#        ex: "pin_patternorder:tdo,extal,tck"
-#
-#      pin_cycle (execute vector data)
-#        ex: "pin_cycle:H11"
-#
-#      pin_clear (clear all setup information)
-#        ex: "pin_clear:"
-#
-#      pin_format (setup a pin with return format)
-#        first argument is the timeset
-#        ex: "pin_format:1,tck,rl"
-#
-#      pin_timing (define when pin events happen)
-#        timing is stored in a timeset hash
-#        first argument is the timeset key
-#        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
-#
-#      version (check version of app server is
-#        running)
-#        ex: "version:"
-#        response ex: "P:0.2.0.pre0"
-##################################################
-module OrigenLink
-  module Server
-    def self.gpio_dir=(path)
-      @gpio_dir = path
-    end
-
-    def self.gpio_dir
-      @gpio_dir || '/sys/class/gpio'
-    end
-
-    ##################################################
-    # OrigenLink::Server::Sequencer Class
-    #
-    #    This class processes messages targeted for
-    #    pin sequencer interface (vector pattern
-    #    execution).
-    #
-    #    Supported messages:
-    #      pin_assign (create pin mapping)
-    #        ex: "pin_assign:tck,3,extal,23,tdo,5"
-    #
-    #      pin_patternorder (define vector pin order)
-    #        ex: "pin_patternorder:tdo,extal,tck"
-    #
-    #      pin_cycle (execute vector data)
-    #        ex: "pin_cycle:H11"
-    #
-    #      pin_clear (clear all setup information)
-    #        ex: "pin_clear:"
-    #
-    #      pin_format (setup a pin with return format)
-    #        first argument is the timeset
-    #        ex: "pin_format:1,tck,rl"
-    #
-    #      pin_timing (define when pin events happen)
-    #        timing is stored in a timeset hash
-    #        first argument is the timeset key
-    #        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
-    #
-    #      version (check version of app server is
-    #        running)
-    #        ex: "version:"
-    #        response ex: "P:0.2.0.pre0"
-    ##################################################
-    class Sequencer
-      # code version of the server (populated by start_link_server)
-      attr_accessor :version
-      # hash holding the pinmap ('name' => pin object)
-      attr_reader :pinmap
-      # array of pin names in pattern order
-      attr_reader :patternorder
-      # hash holding programmed time set information
-      attr_reader :cycletiming
-      # hash holding pin pattern order ('name' => index)
-      attr_reader :patternpinindex
-
-      ##################################################
-      # initialize method
-      #    Create empty pinmap, pattern pin index
-      #    and pattern order instance variables
-      ##################################################
-      def initialize
-        @pinmap = Hash.new(-1)
-        @patternpinindex = Hash.new(-1)
-        @patternorder = []
-        @cycletiming = Hash.new(-1)
-        @version = ''
-      end
-
-      ##################################################
-      # processmessage method
-      #    arguments: message
-      #      message format is <group>_<command>:<args>
-      #    returns: message response
-      #
-      #    This method splits a message into it's
-      #    command and arguments and passes this
-      #    information to the method that performs
-      #    the requested command
-      ##################################################
-      def processmessage(message)
-        command = message.split(':')
-
-        case command[0]
-        when 'pin_assign'
-          pin_assign(command[1])
-        when 'pin_patternorder'
-          pin_patternorder(command[1])
-        when 'pin_cycle'
-          pin_cycle(command[1])
-        when 'pin_clear'
-          pin_clear
-        when 'pin_format'
-          pin_format(command[1])
-        when 'pin_timing'
-          pin_timing(command[1])
-        when 'pin_timingv2'
-          pin_timingv2(command[1])
-        when 'version'
-          "P:#{@version}"
-        else
-          'Error Invalid command: ' + command[0].to_s
-        end
-      end
-
-      ##################################################
-      # pin_assign method
-      #    arguments: <args> from the message request
-      #      see "processmessage" method
-      #    returns: "P:" or error message
-      #
-      #    This method creates a pin instance for each
-      #    pin in the pin map and builds the pinmap
-      #    hash.  Before the pinmap is created, any
-      #    information from a previous pattern run is
-      #    cleared.
-      ##################################################
-      def pin_assign(args)
-        pin_clear
-        success = true
-        fail_message = ''
-        argarr = args.split(',')
-        0.step(argarr.length - 2, 2) do |index|
-          @pinmap[argarr[index]] = Pin.new(argarr[index + 1])
-          unless @pinmap[argarr[index]].gpio_valid
-            success = false
-            fail_message = fail_message + 'pin ' + argarr[index] + ' gpio' + argarr[index + 1] + ' is invalid'
-          end
-        end
-        if success
-          'P:'
-        else
-          'F:' + fail_message
-        end
-      end
-
-      ########################################################
-      # pin_timingv2 method
-      #   arguments: <args> from the message request
-      #     Should be '1,drive,5,pin,10,pin2,|compare,0,pin3'
-      #     First integer is timeset number
-      #
-      #   returns "P:" or error message
-      #
-      #   This method sets up a time set.  Any arbitrary
-      #   waveform can be generated
-      #
-      ########################################################
-      def pin_timingv2(args)
-        # get the tset number
-        argarr = args.split(',')
-        tset_key = argarr.delete_at(0).to_i
-        new_timeset(tset_key)
-        args = argarr.join(',')
-
-        invalid_pins = []
-
-        # process and load the timeset
-        waves = args.split('|')
-        waves.each do |w|
-          argarr = w.split(',')
-          wave_type = argarr.delete_at(0)
-          event_data_key = wave_type + '_event_data'
-          event_pins_key = wave_type + '_event_pins'
-          w = argarr.join(',')
-          events = w.split(';')
-          events.each do |e|
-            argarr = e.split(',')
-            event_key = argarr.delete_at(0).to_f
-            @cycletiming[tset_key]['events'] << event_key
-            @cycletiming[tset_key][event_data_key][event_key] = [] unless @cycletiming[tset_key][event_data_key].key?(event_key)
-            @cycletiming[tset_key][event_data_key][event_key] << argarr.delete_at(0)
-            # now load the pins for this event
-            @cycletiming[tset_key][event_pins_key][event_key] = [] unless @cycletiming[tset_key][event_pins_key].key?(event_key)
-            @cycletiming[tset_key][event_pins_key][event_key] << []
-            argarr.each do |pin|
-              if @pinmap.key?(pin)
-                @cycletiming[tset_key][event_pins_key][event_key].last << @pinmap[pin]
-              else
-                invalid_pins << pin
-              end
-            end # of argarr.each
-          end # of events.each
-        end # of waves.each
-        @cycletiming[tset_key]['events'].uniq!
-        @cycletiming[tset_key]['events'].sort!
-
-        # return result
-        if invalid_pins.size > 0
-          'F:Invalid pins (not in pinmap): ' + invalid_pins.join(', ')
-        else
-          'P:'
-        end
-      end # of def pin_timingv2
-
-      ##################################################
-      # new_timeset(tset)
-      #   creates a new empty timeset hash
-      #
-      #   timing format:
-      #     ['events'] = [0, 5, 10, 35]
-      #     ['drive_event_data'] = {
-      #           0: ['data']
-      #          10: ['data','0']
-      #          35: ['0']
-      #         }
-      #     ['drive_event_pins'] = {
-      #           0: [[pin_obj1, pin_obj2]]
-      #          10: [[pin1,pin2], [pin3]]
-      #           etc.
-      #         }
-      ##################################################
-      def new_timeset(tset)
-        @cycletiming[tset] = {}
-        @cycletiming[tset]['events'] = []
-        @cycletiming[tset]['drive_event_data'] = {}
-        @cycletiming[tset]['drive_event_pins'] = {}
-        @cycletiming[tset]['compare_event_data'] = {}
-        @cycletiming[tset]['compare_event_pins'] = {}
-      end
-
-      ##################################################
-      # pin_format method
-      #   arguments: <args> from the message request
-      #     Should be <timeset>,<pin>,rl or rh
-      #     multi-clock not currently supported
-      #
-      ##################################################
-      def pin_format(args)
-        argarr = args.split(',')
-        tset_key = argarr.delete_at(0).to_i
-        new_timeset(tset_key) unless @cycletiming.key?(tset_key)
-        @cycletiming[tset_key]['events'] += [1, 3]
-        @cycletiming[tset_key]['events'].sort!
-        [1, 3].each do |event|
-          @cycletiming[tset_key]['drive_event_pins'][event] = [[]]
-        end
-        @cycletiming[tset_key]['compare_event_data'][1] = ['data']
-        0.step(argarr.length - 2, 2) do |index|
-          drive_type = argarr[index + 1]
-          pin_name = argarr[index]
-          @cycletiming[tset_key]['drive_event_data'][1] = ['data']
-          @cycletiming[tset_key]['drive_event_pins'][1][0] << @pinmap[pin_name]
-          @cycletiming[tset_key]['drive_event_pins'][3][0] << @pinmap[pin_name]
-          @cycletiming[tset_key]['compare_event_pins'][1] = [[@pinmap[pin_name]]]
-          if drive_type == 'rl'
-            @cycletiming[tset_key]['drive_event_data'][3] = ['0']
-          else
-            @cycletiming[tset_key]['drive_event_data'][3] = ['1']
-          end
-        end
-        'P:'
-      end
-
-      ##################################################
-      # pin_timing method
-      #   arguments: <args> from the message request
-      #     Should be '1,pin,-1,pin2,0,pin3,1'
-      #     First integer is timeset number
-      #     If argument is '', default timing is created
-      #     Default timeset number is 0, this is used
-      #     if no timeset is explicitly defined
-      #
-      #     cycle arg:  0   1   2
-      #     waveform : ___/***\___
-      #
-      #   returns "P:" or error message
-      #
-      #   This method sets up a time set.  All retrun
-      #   format pins are driven between 0 and 1 and
-      #   return between 1 and 2.  Non-return pins are
-      #   acted upon during the 0, 1 or 2 time period.
-      #
-      ##################################################
-      def pin_timing(args)
-        argarr = args.split(',')
-        tset_key = argarr.delete_at(0).to_i
-        new_timeset(tset_key) unless @cycletiming.key?(tset_key)
-        [0, 2, 4].each do |event|
-          @cycletiming[tset_key]['drive_event_pins'][event] = [[]]
-          @cycletiming[tset_key]['compare_event_pins'][event] = [[]]
-        end
-
-        # process the information received
-        0.step(argarr.length - 2, 2) do |index|
-          event = argarr[index + 1].to_i
-          # reorder event number to allow rising/falling edges
-          event *= 2
-          pin_name = argarr[index]
-          @cycletiming[tset_key]['events'] << event
-          @cycletiming[tset_key]['drive_event_data'][event] = ['data']
-          @cycletiming[tset_key]['drive_event_pins'][event][0] << @pinmap[pin_name]
-          @cycletiming[tset_key]['compare_event_data'][event] = ['data']
-          @cycletiming[tset_key]['compare_event_pins'][event][0] << @pinmap[pin_name]
-        end
-
-        # remove events with no associated pins
-        @cycletiming[tset_key]['events'].uniq!
-        @cycletiming[tset_key]['events'].sort!
-        [0, 2, 4].each do |event|
-          if @cycletiming[tset_key]['drive_event_pins'][event][0].size == 0
-            @cycletiming[tset_key]['events'] -= [event]
-            @cycletiming[tset_key]['drive_event_data'].delete(event)
-            @cycletiming[tset_key]['drive_event_pins'].delete(event)
-            @cycletiming[tset_key]['compare_event_data'].delete(event)
-            @cycletiming[tset_key]['compare_event_pins'].delete(event)
-          end
-        end
-        'P:'
-      end
-
-      ##################################################
-      # pin_patternorder method
-      #    arguments: <args> from the message request
-      #    returns: "P:" or error message
-      #
-      #    This method is used to define the order
-      #    for pin vector data.
-      ##################################################
-      def pin_patternorder(args)
-        argarr = args.split(',')
-        index = 0
-        new_timeset(0)
-        argarr.each do |pin|
-          @patternorder << pin
-          @pinmap[pin].pattern_index = index	# pattern index stored in pin object now
-          @patternpinindex[pin] = index		# to be removed
-
-          # define default timing
-          @cycletiming[0]['events'] << index
-          @cycletiming[0]['drive_event_data'][index] = ['data']
-          @cycletiming[0]['drive_event_pins'][index] = [[@pinmap[pin]]]
-          @cycletiming[0]['compare_event_data'][index] = ['data']
-          @cycletiming[0]['compare_event_pins'][index] = [[@pinmap[pin]]]
-          index += 1
-        end
-        'P:'
-      end
-
-      ##################################################
-      # pin_cycle method
-      #    arguments: <args> from the message request
-      #    returns: "P:" or "F:" followed by results
-      #
-      #    This method executes one cycle of pin vector
-      #    data.  The vector data is decomposed and
-      #    sequenced.  Each pin object and pin data
-      #    is passed to the "process_pindata" method
-      #    for decoding and execution
-      #
-      ##################################################
-      def pin_cycle(args)
-        # set default repeats and timeset
-        repeat_count = 1
-        tset = 0
-        if args =~ /,/
-          parsedargs = args.split(',')
-          args = parsedargs.pop
-          parsedargs.each do |arg|
-            if arg =~ /repeat/
-              repeat_count = arg.sub(/repeat/, '').to_i
-            elsif arg =~ /tset/
-              tset = arg.sub(/tset/, '').to_i
-            end
-          end
-        end
-
-        message = ''
-        # load pattern cycle data into pin objects
-        @pinmap.each_value { |p| p.load_pattern_data(args) }
-        cycle_failure = false
-
-        0.upto(repeat_count - 1) do |count|
-          # process timing events
-          @cycletiming[tset]['events'].each do |event|
-            # process drive events
-            if @cycletiming[tset]['drive_event_pins'].key?(event)
-              @cycletiming[tset]['drive_event_pins'][event].each_index do |i|
-                @cycletiming[tset]['drive_event_pins'][event][i].each do |p|
-                  p.process_event(:drive, @cycletiming[tset]['drive_event_data'][event][i])
-                end
-              end
-            end
-
-            # process compare events
-            if @cycletiming[tset]['compare_event_pins'].key?(event)
-              @cycletiming[tset]['compare_event_pins'][event].each_index do |i|
-                @cycletiming[tset]['compare_event_pins'][event][i].each do |p|
-                  p.process_event(:compare, @cycletiming[tset]['compare_event_data'][event][i])
-                end
-              end
-            end
-          end # event
-
-          # build response message
-          message += ' ' unless count == 0
-
-          @patternorder.each do |p|
-            message += @pinmap[p].response
-            cycle_failure = true if @pinmap[p].cycle_failure
-          end
-        end # count
-        if cycle_failure
-          rtnmsg = 'F:' + message + '    Expected:' + args
-        else
-          rtnmsg = 'P:' + message
-        end
-        rtnmsg
-      end
-
-      ##################################################
-      # pin_clear method
-      #
-      #    This method clears all storage objects.  It
-      #    is called by the "pin_assign" method
-      ##################################################
-      def pin_clear
-        @pinmap.each { |pin_name, pin| pin.destroy }
-        @pinmap.clear
-        @patternpinindex.clear
-        @patternorder.delete_if { true }
-        @cycletiming.clear
-        'P:'
-      end
-    end
-  end
-end
+require 'origen_link/server/pin'
+
+##################################################
+# OrigenLink::Server::Sequencer Class
+#    Instance variables:
+#      pinmap: hash with ["pin name"] = pin object
+#      patternpinindex: hash with ["pin name"] =
+#        integer index into vector data
+#      patternpinorder: Array with pin names in
+#        the vector order
+#
+#    This class processes messages targeted for
+#    pin sequencer interface (vector pattern
+#    execution).
+#
+#    Supported messages:
+#      pin_assign (create pin mapping)
+#        ex: "pin_assign:tck,3,extal,23,tdo,5"
+#
+#      pin_patternorder (define vector pin order)
+#        ex: "pin_patternorder:tdo,extal,tck"
+#
+#      pin_cycle (execute vector data)
+#        ex: "pin_cycle:H11"
+#
+#      pin_clear (clear all setup information)
+#        ex: "pin_clear:"
+#
+#      pin_format (setup a pin with return format)
+#        first argument is the timeset
+#        ex: "pin_format:1,tck,rl"
+#
+#      pin_timing (define when pin events happen)
+#        timing is stored in a timeset hash
+#        first argument is the timeset key
+#        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
+#
+#      version (check version of app server is
+#        running)
+#        ex: "version:"
+#        response ex: "P:0.2.0.pre0"
+##################################################
+module OrigenLink
+  module Server
+    def self.gpio_dir=(path)
+      @gpio_dir = path
+    end
+
+    def self.gpio_dir
+      @gpio_dir || '/sys/class/gpio'
+    end
+
+    ##################################################
+    # OrigenLink::Server::Sequencer Class
+    #
+    #    This class processes messages targeted for
+    #    pin sequencer interface (vector pattern
+    #    execution).
+    #
+    #    Supported messages:
+    #      pin_assign (create pin mapping)
+    #        ex: "pin_assign:tck,3,extal,23,tdo,5"
+    #
+    #      pin_patternorder (define vector pin order)
+    #        ex: "pin_patternorder:tdo,extal,tck"
+    #
+    #      pin_cycle (execute vector data)
+    #        ex: "pin_cycle:H11"
+    #
+    #      pin_clear (clear all setup information)
+    #        ex: "pin_clear:"
+    #
+    #      pin_format (setup a pin with return format)
+    #        first argument is the timeset
+    #        ex: "pin_format:1,tck,rl"
+    #
+    #      pin_timing (define when pin events happen)
+    #        timing is stored in a timeset hash
+    #        first argument is the timeset key
+    #        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
+    #
+    #      version (check version of app server is
+    #        running)
+    #        ex: "version:"
+    #        response ex: "P:0.2.0.pre0"
+    ##################################################
+    class Sequencer
+      # code version of the server (populated by start_link_server)
+      attr_accessor :version
+      # hash holding the pinmap ('name' => pin object)
+      attr_reader :pinmap
+      # array of pin names in pattern order
+      attr_reader :patternorder
+      # hash holding programmed time set information
+      attr_reader :cycletiming
+      # hash holding pin pattern order ('name' => index)
+      attr_reader :patternpinindex
+
+      ##################################################
+      # initialize method
+      #    Create empty pinmap, pattern pin index
+      #    and pattern order instance variables
+      ##################################################
+      def initialize
+        @pinmap = Hash.new(-1)
+        @patternpinindex = Hash.new(-1)
+        @patternorder = []
+        @cycletiming = Hash.new(-1)
+        @version = ''
+      end
+
+      ##################################################
+      # processmessage method
+      #    arguments: message
+      #      message format is <group>_<command>:<args>
+      #    returns: message response
+      #
+      #    This method splits a message into it's
+      #    command and arguments and passes this
+      #    information to the method that performs
+      #    the requested command
+      ##################################################
+      def processmessage(message)
+        command = message.split(':')
+
+        case command[0]
+        when 'pin_assign'
+          pin_assign(command[1])
+        when 'pin_patternorder'
+          pin_patternorder(command[1])
+        when 'pin_cycle'
+          pin_cycle(command[1])
+        when 'pin_clear'
+          pin_clear
+        when 'pin_format'
+          pin_format(command[1])
+        when 'pin_timing'
+          pin_timing(command[1])
+        when 'pin_timingv2'
+          pin_timingv2(command[1])
+        when 'version'
+          "P:#{@version}"
+        else
+          'Error Invalid command: ' + command[0].to_s
+        end
+      end
+
+      ##################################################
+      # pin_assign method
+      #    arguments: <args> from the message request
+      #      see "processmessage" method
+      #    returns: "P:" or error message
+      #
+      #    This method creates a pin instance for each
+      #    pin in the pin map and builds the pinmap
+      #    hash.  Before the pinmap is created, any
+      #    information from a previous pattern run is
+      #    cleared.
+      ##################################################
+      def pin_assign(args)
+        pin_clear
+        success = true
+        fail_message = ''
+        argarr = args.split(',')
+        0.step(argarr.length - 2, 2) do |index|
+          @pinmap[argarr[index]] = Pin.new(argarr[index + 1])
+          unless @pinmap[argarr[index]].gpio_valid
+            success = false
+            fail_message = fail_message + 'pin ' + argarr[index] + ' gpio' + argarr[index + 1] + ' is invalid'
+          end
+        end
+        if success
+          'P:'
+        else
+          'F:' + fail_message
+        end
+      end
+
+      ########################################################
+      # pin_timingv2 method
+      #   arguments: <args> from the message request
+      #     Should be '1,drive,5,pin,10,pin2,|compare,0,pin3'
+      #     First integer is timeset number
+      #
+      #   returns "P:" or error message
+      #
+      #   This method sets up a time set.  Any arbitrary
+      #   waveform can be generated
+      #
+      ########################################################
+      def pin_timingv2(args)
+        # get the tset number
+        argarr = args.split(',')
+        tset_key = argarr.delete_at(0).to_i
+        new_timeset(tset_key)
+        args = argarr.join(',')
+
+        invalid_pins = []
+
+        # process and load the timeset
+        waves = args.split('|')
+        waves.each do |w|
+          argarr = w.split(',')
+          wave_type = argarr.delete_at(0)
+          event_data_key = wave_type + '_event_data'
+          event_pins_key = wave_type + '_event_pins'
+          w = argarr.join(',')
+          events = w.split(';')
+          events.each do |e|
+            argarr = e.split(',')
+            event_key = argarr.delete_at(0).to_f
+            @cycletiming[tset_key]['events'] << event_key
+            @cycletiming[tset_key][event_data_key][event_key] = [] unless @cycletiming[tset_key][event_data_key].key?(event_key)
+            @cycletiming[tset_key][event_data_key][event_key] << argarr.delete_at(0)
+            # now load the pins for this event
+            @cycletiming[tset_key][event_pins_key][event_key] = [] unless @cycletiming[tset_key][event_pins_key].key?(event_key)
+            @cycletiming[tset_key][event_pins_key][event_key] << []
+            argarr.each do |pin|
+              if @pinmap.key?(pin)
+                @cycletiming[tset_key][event_pins_key][event_key].last << @pinmap[pin]
+              else
+                invalid_pins << pin
+              end
+            end # of argarr.each
+          end # of events.each
+        end # of waves.each
+        @cycletiming[tset_key]['events'].uniq!
+        @cycletiming[tset_key]['events'].sort!
+
+        # return result
+        if invalid_pins.size > 0
+          'F:Invalid pins (not in pinmap): ' + invalid_pins.join(', ')
+        else
+          'P:'
+        end
+      end # of def pin_timingv2
+
+      ##################################################
+      # new_timeset(tset)
+      #   creates a new empty timeset hash
+      #
+      #   timing format:
+      #     ['events'] = [0, 5, 10, 35]
+      #     ['drive_event_data'] = {
+      #           0: ['data']
+      #          10: ['data','0']
+      #          35: ['0']
+      #         }
+      #     ['drive_event_pins'] = {
+      #           0: [[pin_obj1, pin_obj2]]
+      #          10: [[pin1,pin2], [pin3]]
+      #           etc.
+      #         }
+      ##################################################
+      def new_timeset(tset)
+        @cycletiming[tset] = {}
+        @cycletiming[tset]['events'] = []
+        @cycletiming[tset]['drive_event_data'] = {}
+        @cycletiming[tset]['drive_event_pins'] = {}
+        @cycletiming[tset]['compare_event_data'] = {}
+        @cycletiming[tset]['compare_event_pins'] = {}
+      end
+
+      ##################################################
+      # pin_format method
+      #   arguments: <args> from the message request
+      #     Should be <timeset>,<pin>,rl or rh
+      #     multi-clock not currently supported
+      #
+      ##################################################
+      def pin_format(args)
+        argarr = args.split(',')
+        tset_key = argarr.delete_at(0).to_i
+        new_timeset(tset_key) unless @cycletiming.key?(tset_key)
+        @cycletiming[tset_key]['events'] += [1, 3]
+        @cycletiming[tset_key]['events'].sort!
+        [1, 3].each do |event|
+          @cycletiming[tset_key]['drive_event_pins'][event] = [[]]
+        end
+        @cycletiming[tset_key]['compare_event_data'][1] = ['data']
+        0.step(argarr.length - 2, 2) do |index|
+          drive_type = argarr[index + 1]
+          pin_name = argarr[index]
+          @cycletiming[tset_key]['drive_event_data'][1] = ['data']
+          @cycletiming[tset_key]['drive_event_pins'][1][0] << @pinmap[pin_name]
+          @cycletiming[tset_key]['drive_event_pins'][3][0] << @pinmap[pin_name]
+          @cycletiming[tset_key]['compare_event_pins'][1] = [[@pinmap[pin_name]]]
+          if drive_type == 'rl'
+            @cycletiming[tset_key]['drive_event_data'][3] = ['0']
+          else
+            @cycletiming[tset_key]['drive_event_data'][3] = ['1']
+          end
+        end
+        'P:'
+      end
+
+      ##################################################
+      # pin_timing method
+      #   arguments: <args> from the message request
+      #     Should be '1,pin,-1,pin2,0,pin3,1'
+      #     First integer is timeset number
+      #     If argument is '', default timing is created
+      #     Default timeset number is 0, this is used
+      #     if no timeset is explicitly defined
+      #
+      #     cycle arg:  0   1   2
+      #     waveform : ___/***\___
+      #
+      #   returns "P:" or error message
+      #
+      #   This method sets up a time set.  All retrun
+      #   format pins are driven between 0 and 1 and
+      #   return between 1 and 2.  Non-return pins are
+      #   acted upon during the 0, 1 or 2 time period.
+      #
+      ##################################################
+      def pin_timing(args)
+        argarr = args.split(',')
+        tset_key = argarr.delete_at(0).to_i
+        new_timeset(tset_key) unless @cycletiming.key?(tset_key)
+        [0, 2, 4].each do |event|
+          @cycletiming[tset_key]['drive_event_pins'][event] = [[]]
+          @cycletiming[tset_key]['compare_event_pins'][event] = [[]]
+        end
+
+        # process the information received
+        0.step(argarr.length - 2, 2) do |index|
+          event = argarr[index + 1].to_i
+          # reorder event number to allow rising/falling edges
+          event *= 2
+          pin_name = argarr[index]
+          @cycletiming[tset_key]['events'] << event
+          @cycletiming[tset_key]['drive_event_data'][event] = ['data']
+          @cycletiming[tset_key]['drive_event_pins'][event][0] << @pinmap[pin_name]
+          @cycletiming[tset_key]['compare_event_data'][event] = ['data']
+          @cycletiming[tset_key]['compare_event_pins'][event][0] << @pinmap[pin_name]
+        end
+
+        # remove events with no associated pins
+        @cycletiming[tset_key]['events'].uniq!
+        @cycletiming[tset_key]['events'].sort!
+        [0, 2, 4].each do |event|
+          if @cycletiming[tset_key]['drive_event_pins'][event][0].size == 0
+            @cycletiming[tset_key]['events'] -= [event]
+            @cycletiming[tset_key]['drive_event_data'].delete(event)
+            @cycletiming[tset_key]['drive_event_pins'].delete(event)
+            @cycletiming[tset_key]['compare_event_data'].delete(event)
+            @cycletiming[tset_key]['compare_event_pins'].delete(event)
+          end
+        end
+        'P:'
+      end
+
+      ##################################################
+      # pin_patternorder method
+      #    arguments: <args> from the message request
+      #    returns: "P:" or error message
+      #
+      #    This method is used to define the order
+      #    for pin vector data.
+      ##################################################
+      def pin_patternorder(args)
+        argarr = args.split(',')
+        index = 0
+        new_timeset(0)
+        argarr.each do |pin|
+          @patternorder << pin
+          @pinmap[pin].pattern_index = index	# pattern index stored in pin object now
+          @patternpinindex[pin] = index		# to be removed
+
+          # define default timing
+          @cycletiming[0]['events'] << index
+          @cycletiming[0]['drive_event_data'][index] = ['data']
+          @cycletiming[0]['drive_event_pins'][index] = [[@pinmap[pin]]]
+          @cycletiming[0]['compare_event_data'][index] = ['data']
+          @cycletiming[0]['compare_event_pins'][index] = [[@pinmap[pin]]]
+          index += 1
+        end
+        'P:'
+      end
+
+      ##################################################
+      # pin_cycle method
+      #    arguments: <args> from the message request
+      #    returns: "P:" or "F:" followed by results
+      #
+      #    This method executes one cycle of pin vector
+      #    data.  The vector data is decomposed and
+      #    sequenced.  Each pin object and pin data
+      #    is passed to the "process_pindata" method
+      #    for decoding and execution
+      #
+      ##################################################
+      def pin_cycle(args)
+        # set default repeats and timeset
+        repeat_count = 1
+        tset = 0
+        if args =~ /,/
+          parsedargs = args.split(',')
+          args = parsedargs.pop
+          parsedargs.each do |arg|
+            if arg =~ /repeat/
+              repeat_count = arg.sub(/repeat/, '').to_i
+            elsif arg =~ /tset/
+              tset = arg.sub(/tset/, '').to_i
+            end
+          end
+        end
+
+        message = ''
+        # load pattern cycle data into pin objects
+        @pinmap.each_value { |p| p.load_pattern_data(args) }
+        cycle_failure = false
+
+        0.upto(repeat_count - 1) do |count|
+          # process timing events
+          @cycletiming[tset]['events'].each do |event|
+            # process drive events
+            if @cycletiming[tset]['drive_event_pins'].key?(event)
+              @cycletiming[tset]['drive_event_pins'][event].each_index do |i|
+                @cycletiming[tset]['drive_event_pins'][event][i].each do |p|
+                  p.process_event(:drive, @cycletiming[tset]['drive_event_data'][event][i])
+                end
+              end
+            end
+
+            # process compare events
+            if @cycletiming[tset]['compare_event_pins'].key?(event)
+              @cycletiming[tset]['compare_event_pins'][event].each_index do |i|
+                @cycletiming[tset]['compare_event_pins'][event][i].each do |p|
+                  p.process_event(:compare, @cycletiming[tset]['compare_event_data'][event][i])
+                end
+              end
+            end
+          end # event
+
+          # build response message
+          message += ' ' unless count == 0
+
+          @patternorder.each do |p|
+            message += @pinmap[p].response
+            cycle_failure = true if @pinmap[p].cycle_failure
+          end
+        end # count
+        if cycle_failure
+          rtnmsg = 'F:' + message + '    Expected:' + args
+        else
+          rtnmsg = 'P:' + message
+        end
+        rtnmsg
+      end
+
+      ##################################################
+      # pin_clear method
+      #
+      #    This method clears all storage objects.  It
+      #    is called by the "pin_assign" method
+      ##################################################
+      def pin_clear
+        @pinmap.each { |pin_name, pin| pin.destroy }
+        @pinmap.clear
+        @patternpinindex.clear
+        @patternorder.delete_if { true }
+        @cycletiming.clear
+        'P:'
+      end
+    end
+  end
+end