smartware 0.2.8 → 0.3

data/lib/smartware/drivers/common/ccnet_connection.rb

@@ -0,0 +1,135 @@
+require "smartware/drivers/common/command_based_device.rb"
+
+module Smartware
+  class CCNETConnection < CommandBasedDevice
+
+    POLYNOMIAL = 0x8408
+
+    attr_accessor :address
+
+    def initialize
+      super
+
+      @address = 0
+      @command_timer = nil
+    end
+
+    protected
+
+    def remove_timeouts
+      unless @command_timer.nil?
+        EventMachine.cancel_timer @command_timer
+        @command_timer = nil
+      end
+    end
+
+    def install_timeouts
+      @command_timer = EventMachine.add_timer(1) do
+        @command_timer = nil
+        retry_or_fail
+        post_command unless @executing_command
+      end
+    end
+
+    def max_retries
+      8
+    end
+
+    def submit_command(command = nil, data = "")
+      if command.kind_of? Array
+        command, subcommand = command
+      else
+        subcommand = nil
+      end
+
+      if data.length <= 250
+        if command.nil?
+          frame = [ 0x02, @address, data.size + 5 ].pack("C*")
+        elsif subcommand.nil?
+          frame = [ 0x02, @address, data.size + 6, command ].pack("C*")
+        else
+          frame = [ 0x02, @address, data.size + 7, command, subcommand ].pack("C*")
+        end
+      else
+        if command.nil?
+          frame = [ 0x02, @address, 0, data.size + 7 ].pack("C3n")
+        elsif subcommand.nil?
+          frame = [ 0x02, @address, 0, command, data.size + 8 ].pack("C4n")
+        else
+          frame = [ 0x02, @address, 0, command, subcommand, data.size + 9 ].pack("C5n")
+        end
+      end
+
+      frame << data
+      frame << [ crc_for(frame) ].pack("v")
+
+      send_data frame
+    end
+
+    def crc_for(msg)
+      crc = 0
+
+      msg.each_byte do |byte|
+        crc ^= byte
+
+        8.times do
+          if (crc & 1) != 0
+            crc >>= 1
+            crc ^= POLYNOMIAL
+          else
+            crc >>= 1
+          end
+        end
+      end
+
+      crc
+    end
+
+    def handle_response
+      while @buffer.size >= 5
+        short_length = @buffer.getbyte(2)
+        if short_length == 0
+          break if @buffer.size < 7
+
+          length, = @buffer.slice(3, 2).unpack("n")
+        else
+          length = short_length
+        end
+
+        break if @buffer.size < length
+
+        message = @buffer.slice! 0, length
+        crc, = message[-2..-1].unpack("v")
+        expected_crc = crc_for(message[0..-3])
+
+        if expected_crc != crc
+          Logging.logger.warn "bad response CRC: #{expected_crc} expected, #{crc} got"
+
+          retry_or_fail if @executing_command
+          next
+        end
+
+        if message.getbyte(1) != @address
+          Logging.logger.warn "unexpected address: #{@buffer.inspect}"
+
+          next
+        end
+
+        if @executing_command
+          # Acknowlege
+          submit_command nil, "\x00"
+
+          if short_length == 0
+            complete message[5..-3]
+          else
+            complete message[3..-3]
+          end
+        else
+          Logging.logger.warn "unexpected message: #{@buffer.inspect}"
+        end
+      end
+
+      post_command unless @executing_command
+    end
+  end
+end

data/lib/smartware/drivers/common/command_based_device.rb

@@ -0,0 +1,101 @@
+module Smartware
+  class CommandBasedDevice < EventMachine::Connection
+    def initialize
+      @ready_for_commands = true
+      @executing_command = false
+      @retries = nil
+      @command = nil
+      @completion_proc = nil
+      @buffer = ""
+
+      @command_queue = []
+      @command_mutex = Mutex.new
+    end
+
+    def receive_data(data)
+      @buffer << data
+
+      handle_response
+    end
+
+    def command(*args, &block)
+      if !block_given?
+        queue = Queue.new
+        command(*args) do |resp|
+          queue.push resp
+        end
+        queue.pop
+      else
+        @command_mutex.synchronize do
+          @command_queue.push [ args, block ]
+        end
+
+        EventMachine.schedule method(:post_command)
+      end
+    end
+
+    protected
+
+    def ready?
+      @ready_for_commands && !@executing_command
+    end
+
+    def post_command
+      executing_command, command = @command_mutex.synchronize do
+        if ready?
+          [ @command_queue.any?, @command_queue.first ]
+        else
+          [ false, nil ]
+        end
+      end
+
+      if executing_command
+        @executing_command = executing_command
+        install_timeouts
+        @retries = max_retries
+        command, = @command_mutex.synchronize { @command_queue.first }
+        submit_command *command
+      end
+    end
+
+    def kill_queue
+      blocks = nil
+
+      @command_mutex.synchronize do
+        blocks = @command_queue.map { |command, block| block }
+        @command_queue.clear
+
+        @ready_for_commands = false
+      end
+
+      blocks.each do |block|
+        block.call nil
+      end
+    end
+
+    def retry_or_fail
+      if @retries == 0
+        complete nil
+      else
+        @retries -= 1
+        command, = @command_mutex.synchronize { @command_queue.first }
+        remove_timeouts
+        install_timeouts
+        submit_command *command
+      end
+    end
+
+    def complete(data)
+      command, proc = @command_mutex.synchronize { @command_queue.shift }
+      remove_timeouts
+      @executing_command = false
+
+      begin
+        proc.call data
+      rescue => e
+        Logging.logger.error "Error in completion handler: #{e}"
+        e.backtrace.each { |line| Logging.logger.error line }
+      end
+    end
+  end
+end

data/lib/smartware/drivers/common/sankyo_connection.rb

@@ -0,0 +1,154 @@
+require "smartware/drivers/common/command_based_device"
+require "digest/crc16_xmodem"
+
+module Smartware
+  class SankyoConnection < CommandBasedDevice
+    class CommandResponse
+      def initialize(response)
+        @response = response
+      end
+
+      def positive?
+        @response[0] == "P"
+      end
+
+      def negative?
+        @response[0] != "P"
+      end
+
+      def response
+        @response[1..-1]
+      end
+    end
+
+    STX = 0xF2
+    ACK = 0x06
+    NAK = 0x15
+
+    attr_accessor :initialize_device
+
+    def initialize
+      super
+
+      @command_timer = nil
+      @initialize_device = nil
+      @ready_for_commands = false
+      @state = :drop
+
+      EventMachine.add_periodic_timer(10) { check_dsr! }
+      EventMachine.next_tick { check_dsr! }
+    end
+
+    def check_dsr!
+      if @io.dsr == 0
+        @state = :drop
+        kill_queue
+      else
+        was_ready, @ready_for_commands = @ready_for_commands, true
+
+        if !was_ready
+          @initialize_device.call
+        end
+      end
+    end
+
+    protected
+
+    def remove_timeouts
+      unless @command_timer.nil?
+        EventMachine.cancel_timer @command_timer
+        @command_timer = nil
+      end
+    end
+
+    def install_timeouts(type = :sync)
+      interval = nil
+      case type
+      when :sync
+        interval = 0.3
+
+      when :command
+        interval = 20
+
+      else
+        raise "invalid timeout type: #{type.inspect}"
+      end
+
+      @command_timer = EventMachine.add_timer(interval) do
+        @command_timer = nil
+        retry_or_fail
+        post_command unless @executing_command
+      end
+    end
+
+    def max_retries
+      8
+    end
+
+    def submit_command(*bytes)
+      data = [ STX, bytes.length + 1 ].pack("Cn")
+      data << "C"
+      data << bytes.pack("C*")
+
+      crc = Digest::CRC16XModem.new
+      crc << data
+      data << [ crc.checksum ].pack("n")
+
+      @state = :sync
+      send_data data
+    end
+
+    def complete(response)
+      @state = :drop
+      super
+    end
+
+    def handle_response
+      until @buffer.empty?
+        case @state
+        when :drop
+          @buffer.clear
+
+        when :sync
+          initial_byte = @buffer.slice!(0, 1).ord
+
+          case initial_byte
+          when ACK
+            @state = :response
+            remove_timeouts
+            install_timeouts :command
+
+          when NAK
+            retry_or_fail
+          end
+
+        when :response
+          break if @buffer.length < 5
+
+          leading_byte, length = @buffer[0..2].unpack("Cn")
+          if leading_byte != STX
+            @buffer.slice! 0, 1
+            next
+          end
+
+          full_length = 5 + length
+
+          break if @buffer.length < full_length
+
+          message = @buffer.slice! 0, full_length
+          sum, = message.slice!(full_length - 2, 2).unpack("n")
+          crc = Digest::CRC16XModem.new
+          crc << message
+          if sum == crc.checksum
+            send_data ACK.chr
+            complete CommandResponse.new(message[3..-1])
+          else
+            send_data NAK.chr
+          end
+        end
+      end
+
+      post_command
+    end
+  end
+end

data/lib/smartware/interfaces/cash_acceptor.rb

@@ -19,9 +19,28 @@ module Smartware
       CAPACITANCE_CANAL_FAILURE = 15
       COMMUNICATION_ERROR = 16
 
+      class BillType
+        attr_reader :value
+        attr_reader :country
+
+        def initialize(value, country)
+          @value = value
+          @country = country
+        end
+
+        def to_s
+          "#{@country}:#{@value}"
+        end
+      end
+
       def initialize(config)
         super
 
+        @device.escrow = method :escrow
+        @device.stacked = method :stacked
+        @device.returned = method :returned
+        @device.status = method :status
+
         @limit = nil
         @banknotes = {}
         @banknotes.default = 0
@@ -30,12 +49,6 @@ module Smartware
           @status[:casette] = true
         end
 
-        @accepting = false
-        @commands = Queue.new
-        @commands.push :close
-
-        Thread.new &method(:dispatch_commands)
-        Thread.new &method(:periodic)
         Smartware::Logging.logger.info "Cash acceptor monitor started"
       end
 
@@ -45,21 +58,34 @@ module Smartware
         if limit_min.nil? || limit_max.nil?
           @limit = nil
 
-          Smartware::Logging.logger.info "Session open, unlimited"
+          Smartware::Logging.logger.debug "Session open, unlimited"
         else
           @limit = limit_min..limit_max
 
-          Smartware::Logging.logger.info "Session open, limit: #{@limit}"
+          Smartware::Logging.logger.debug "Session open, limit: #{@limit}"
         end
 
-        @commands.push :open
-        @commands.push :get_money
+        EventMachine.schedule do
+          types = 0
+          @device.bill_types.each_with_index do |type, index|
+            next if type.nil?
+
+            if type.country == 'RUS'
+              types |= 1 << index
+            end
+          end
+
+          @device.enabled_types = types
+        end
       end
 
       def close_session
-        Smartware::Logging.logger.info "Session closed"
+        Smartware::Logging.logger.debug "Session closed"
+
+        EventMachine.schedule do
+          @device.enabled_types = 0
+        end
 
-        @commands.push :close
         @limit = nil
       end
 
@@ -75,110 +101,36 @@ module Smartware
 
       private
 
-      def limit_satisfied(sum)
+      def limit_satisfied?(sum)
         @limit.nil? or @limit.include? sum
       end
 
-      def execute_open
-        @device.reset
-        @device.accept
-        Smartware::Logging.logger.info "Cash acceptor open"
-
-        @accepting = true
+      def escrow(banknote)
+        limit_satisfied?(self.cashsum + banknote.value)
       end
 
-      def execute_get_money
-        res = @device.current_banknote
+      def stacked(banknote)
+        value = banknote.value
 
-        case res
-        when Integer
-          if limit_satisfied(self.cashsum + res)
-            @device.stack
-            update_status do
-              @banknotes[res] += 1
-            end
-            Smartware::Logging.logger.info "Cash acceptor bill stacked, #{res}"
-          else
-            @device.return
-            Smartware::Logging.logger.info "Cash acceptor limit violation, return #{res}"
-          end
-
-        when String
-          Smartware::Logging.logger.error "Cash acceptor error #{res}"
-
-          update_status do
-            @status[:error] = res
-          end
+        update_status do
+          @banknotes[value] += 1
         end
 
-        if !@limit.nil? && @limit.end > 0 && @limit.end == self.cashsum
-          # Close cash acceptor if current cashsum equal max-limit
-
-          execute_close
-        end
+        Smartware::Logging.logger.debug "cash acceptor: bill stacked, #{value}"
       end
 
-      def execute_close
-        @device.cancel_accept
-        Smartware::Logging.logger.info "Cash acceptor close"
+      def returned(banknote)
+        value = banknote.value
 
-        @accepting = false
+        Smartware::Logging.logger.debug "cash acceptor: bill returned, #{value}"
       end
 
-      def execute_monitor
-        error = @device.error
-        model = @device.model
-        version = @device.version
-        cassette = @device.cassette?
-
+      def status(error)
         update_status do
           @status[:error] = error
-          @status[:model] = model
-          @status[:version] = version
-          @status[:cassette] = cassette
-        end
-      end
-
-      def dispatch_commands
-        loop do
-          command = @commands.pop
-
-          begin
-            start = Time.now
-
-            send :"execute_#{command}"
-
-            complete = Time.now
-            if complete - start > 1
-              Smartware::Logging.logger.warn "#{command} has been running for #{complete - start} seconds."
-            end
-
-          rescue => e
-            Smartware::Logging.logger.error "Execution of #{command} failed:"
-            Smartware::Logging.logger.error e.to_s
-            e.backtrace.each do |line|
-              Smartware::Logging.logger.error line
-            end
-          end
-        end
-      end
-
-      def periodic
-        loop do
-          begin
-            if @commands.empty?
-              @commands.push :monitor
-              @commands.push :get_money if @accepting
-            end
-
-            sleep 0.5
-          rescue => e
-            Smartware::Logging.logger.error "Error in periodic failed:"
-            Smartware::Logging.logger.error e.to_s
-            e.backtrace.each do |line|
-              Smartware::Logging.logger.error line
-            end
-          end
+          @status[:model] = @device.model
+          @status[:version] = @device.version
+          @status[:casette] = error != DROP_CASETTE_OUT_OF_POSITION
         end
       end
     end