omg-networked-rfid 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ec1fd8a964b3c137be3bb309649c672ceb72e2ac
+  data.tar.gz: 6cbd02116b67f6043c9b29f390a19ff2d55c1f8f
+SHA512:
+  metadata.gz: fdc68017e05d5ce67196447f76418bb6f33868e84d89ac2e038da5180a14ab845546c36075b1256f8d78a0c0df3302487f91f5e095749e2e0c203f7a3f0c66d6
+  data.tar.gz: 3229ccd254962a9d419793df9b274ee972edcc1b996478ab8290d83062ed1abbb903a25aaa693ee901952eba0ec9b15f26166ad3736e764436f6e96bd16460bf

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in omg-networked-rfid.gemspec
+gemspec

data/README.md

@@ -0,0 +1,72 @@
+# Omg-Networked-Rfid
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'omg-networked-rfid'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install omg-networked-rfid
+
+## Usage
+
+It provides a few basic classes that you can use to read RFID cards remotely.
+
+* ```NetworkedRFID::RFIDReaderRepository``` provides a repository for collective RFID reader polling.
+
+* ```NetworkedRFID::RemoteRFIDReader``` gives you a networked reader you can later add the repository. It delegates card reader events to a higher level delegate.
+
+* ```NetworkedRFID::CardApplicationDelegate``` one of the delegates that can process ```NetworkedRFID::RemoteRFIDReader``` events. It translates those low-level events into card application events, which are then delegated further to a delegate of your choice. Your delegate is required to support only one method: ```card_scanned(card_number)```.
+
+### Example
+
+Here's how you can read your cards using RFID cardreader and output their
+numbers to the console.
+
+```ruby
+require "bundler"
+Bundler.require
+
+# Your sample upper-level delegate
+class SampleCardProcessingDelegate
+
+  def card_scanned(card_number)
+    puts "Card has been scanned: #{card_number}"
+  end
+
+end
+
+# Make an instance of your delegate
+card_processing_delegate = SampleCardProcessingDelegate.new
+
+# Assign it to a message-level delegate
+card_application_delegate = NetworkedRFID::CardApplicationDelegate.new
+card_application_delegate.delegate = card_processing_delegate
+
+# Create new RFID reader and add the message-level delegate to it
+reader = NetworkedRFID::RemoteRFIDReader.new("192.168.1.100", 2000)
+reader.delegate = card_application_delegate
+
+# Finally add newly created RFID reader to the repository
+repository = NetworkedRFID::RFIDReaderRepository.new
+repository << reader
+
+# Start main polling cycle
+while true
+  repository.poll
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Merge Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/networked_rfid/card_application_delegate.rb

@@ -0,0 +1,43 @@
+module NetworkedRFID
+
+  # Делегат, обрабатывающий события кардридера и преобразовывающий их в события
+  # прикладывания карты.
+  #
+  # События прикладывания карты обрабатываются методом +card_scanned(number)+
+  # делегата.
+  class CardApplicationDelegate
+
+    attr_accessor :delegate, :card_number
+
+    state_machine :state, :initial => :waiting do
+
+      event :rfid_read do
+        transition :waiting => :card_applied
+        transition :card_applied => :card_applied
+      end
+
+      event :poll_reply do
+        transition :card_applied => :waiting
+      end
+
+      state :waiting
+      state :card_applied
+
+      before_transition any => :card_applied do |object, transition|
+        throw :halt if object.card_number == transition.args.first.card_number
+      end
+
+      after_transition any => :card_applied do |object, transition|
+        object.card_number = transition.args.first.card_number
+        object.delegate.card_scanned(object.card_number)
+      end
+
+      after_transition :card_applied => :waiting do |object|
+        object.card_number = nil
+      end
+
+    end
+
+  end
+
+end

data/lib/networked_rfid/remote_rfid_reader.rb

@@ -0,0 +1,37 @@
+module NetworkedRFID
+
+  # Класс отдельного TCP/IP-ридера, отвечающий за его опрос и передачу событий
+  # делегату +delegate+.
+  #
+  # У делегата должны быть определены методы-обработчики низкоуровневых событий
+  # кард-ридера вроде +poll_reply+ и +rfid_read+.
+  class RemoteRFIDReader
+    POLL_PACKET = [ 0x02, 0xe0, 0x00, 0x98, 0x02,
+                    0x00, 0x01, 0x7b, 0x03 ].pack('C*')
+
+    attr_reader :ip, :port
+    attr_accessor :delegate
+
+    # Инициализирует ридер, делая его доступным по _ip_ на порту _port_.
+    def initialize(ip, port)
+      @ip = ip
+      @port = port
+      @delegate = delegate
+    end
+
+    # Отправлять запрос на опрос состояния ридера через _socket_.
+    def poll(socket)
+      socket.send POLL_PACKET, 0, ip, port
+    end
+
+    # Обрабатывает двоичный ответ _response_ от ридера и отправяет его
+    # делегату.
+    def process_response(response)
+      response = RFIDReply.read(response)
+      if delegate.respond_to?(response.type)
+        delegate.send(response.type, response.payload)
+      end
+    end
+  end
+
+end

data/lib/networked_rfid/rfid_card_read_reply.rb

@@ -0,0 +1,14 @@
+module NetworkedRFID
+
+  # Ответ на запрос о состоянии, когда карта приложена к ридеру.
+  class RFIDCardReadReply < BinData::Record
+    skip   length: 1
+    array :card_number_bytes, type: :uint8, initial_length: 7
+
+    # Номер приложенной карты.
+    def card_number
+      card_number_bytes.to_a.reverse.inject(0) { |number, byte| (number << 8) + byte }
+    end
+  end
+
+end

data/lib/networked_rfid/rfid_controller_service.rb

@@ -0,0 +1,76 @@
+module NetworkedRFID
+
+protected
+
+  module ReaderControlMethods
+
+    class << self
+
+      def included(klass)
+        methods = {
+          beep: {
+            once: {
+              short: [ 0x02, 0xa0, 0x00, 0x26, 0x07, 0x00, 0x04, 0x01, 0x00, 0x00, 0x00, 0x01, 0x85, 0x03 ],
+              long:  [ 0x02, 0xe0, 0x00, 0x26, 0x07, 0x00, 0x04, 0x05, 0x00, 0x00, 0x00, 0x01, 0xc1, 0x03 ]
+            },
+            twice: [ 0x02, 0xe0, 0x00, 0x26, 0x07, 0x00, 0x04, 0x01, 0x00, 0x01, 0x01, 0x01, 0xc5, 0x03 ]
+          },
+          lights: {
+            off:      [ 0x02, 0xb0, 0x00, 0x24, 0x02, 0x00, 0x00, 0x96, 0x03 ],
+            red_on:   [ 0x02, 0xa0, 0x00, 0x24, 0x02, 0x00, 0x01, 0x87, 0x03 ],
+            green_on: [ 0x02, 0xb0, 0x00, 0x24, 0x02, 0x00, 0x02, 0x94, 0x03 ],
+            both_on:  [ 0x02, 0xb0, 0x00, 0x24, 0x02, 0x00, 0x03, 0x94, 0x03 ]
+          }
+        }
+    
+        mod = Module.new
+  
+        load_methods methods, [ ] do |method, packet|
+          klass.send :define_method, method do |ip|
+            socket = UDPSocket.new
+            socket.send packet.pack("C*"), 0, ip, 2000
+            socket.recv 16
+            socket.close
+          end
+        end
+    
+        klass.include(mod)
+    
+      end
+
+    private
+
+      def load_methods(methods, path, &block)
+        methods.each do |key, value|
+          if value.kind_of?(Array)
+            yield (path + [ key ]).join("_"), value
+          else
+            load_methods(value, path + [ key ], &block)
+          end
+        end
+      end    
+
+    end
+
+  end
+
+public
+
+  # Синглтон-сервис, обеспечивающий отправку команд ридеру в одностороннем
+  # порядке.
+  #
+  # Позволяет отправлять команды на включение лампочек, пищание и др.
+  #
+  # Полный перечень методов:
+  #   +RFIDControllerService.instance.public_methods(false)+
+  class RFIDControllerService
+  
+    include ReaderControlMethods
+  
+    def self.instance
+      @instance ||= new
+    end
+  
+  end
+
+end

data/lib/networked_rfid/rfid_poll_reply.rb

@@ -0,0 +1,7 @@
+module NetworkedRFID
+
+  # Пустой ответ на запрос о состоянии ридера.
+  class RFIDPollReply < BinData::Record
+  end
+
+end

data/lib/networked_rfid/rfid_reader_repository.rb

@@ -0,0 +1,41 @@
+module NetworkedRFID
+
+  # Репозиторий всех ридеров, с которыми взаимодействует система.
+  class RFIDReaderRepository
+
+    # Опросить состояние ридеров и передать каждому полученный ответ
+    # на обработку.
+    def poll
+      readers.values.each do |reader|
+        reader.poll(socket)
+      end
+
+      while have_replies?
+        reply_packet = socket.recvfrom_nonblock(64)
+        readers[reply_packet[1][2].to_s].process_response reply_packet[0]
+      end
+    end
+
+    # Добавить ридер в репозиторий.
+    def <<(reader)
+      readers[reader.ip] = reader
+    end
+
+  protected
+
+    def have_replies?
+      result = IO.select([ socket ], nil, nil, 0.125)
+      !result.nil? && result[0].size > 0
+    end
+
+    def socket
+      @socket ||= UDPSocket.new
+    end
+
+    def readers
+      @readers ||= { }
+    end
+
+  end
+
+end

data/lib/networked_rfid/rfid_reply.rb

@@ -0,0 +1,27 @@
+module NetworkedRFID
+
+  # Двоичная структура ответа на запрос о состоянии ридера.
+  class RFIDReply < BinData::Record
+    POLL_REPLY = 1
+    RFID_READ  = 8
+
+    skip  length: 3
+    uint8 :packet_type
+
+    choice :payload, :selection => ->{ packet_type } do
+      rfid_poll_reply 1
+      rfid_card_read_reply 8
+      rest :default
+    end
+
+    # Тип ответа.
+    def type
+      {
+        POLL_REPLY => :poll_reply,
+        RFID_READ  => :rfid_read
+      }[packet_type]
+    end
+
+  end
+
+end

data/lib/omg-networked-rfid.rb

@@ -0,0 +1,10 @@
+require "bindata"
+require "state_machine"
+
+require_relative "networked_rfid/card_application_delegate"
+require_relative "networked_rfid/remote_rfid_reader"
+require_relative "networked_rfid/rfid_card_read_reply"
+require_relative "networked_rfid/rfid_poll_reply"
+require_relative "networked_rfid/rfid_reader_repository"
+require_relative "networked_rfid/rfid_reply"
+require_relative "networked_rfid/rfid_controller_service"

data/omg-networked-rfid.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "omg-networked-rfid"
+  spec.version       = "2.1.0"
+  spec.authors       = ["Ivan Kasatenko"]
+  spec.email         = ["sky.31338@gmail.com"]
+  spec.description   = %q{Networked RFID support library}
+  spec.summary       = %q{Library that gives a basic framework to support networked RFID CV5600 reader}
+  spec.homepage      = ""
+  spec.license       = "Commercial"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "bindata"
+  spec.add_dependency "state_machine"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: omg-networked-rfid
+version: !ruby/object:Gem::Version
+  version: 2.1.0
+platform: ruby
+authors:
+- Ivan Kasatenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: state_machine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Networked RFID support library
+email:
+- sky.31338@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/networked_rfid/card_application_delegate.rb
+- lib/networked_rfid/remote_rfid_reader.rb
+- lib/networked_rfid/rfid_card_read_reply.rb
+- lib/networked_rfid/rfid_controller_service.rb
+- lib/networked_rfid/rfid_poll_reply.rb
+- lib/networked_rfid/rfid_reader_repository.rb
+- lib/networked_rfid/rfid_reply.rb
+- lib/omg-networked-rfid.rb
+- omg-networked-rfid.gemspec
+- vendor/cache/bindata-1.6.0.gem
+- vendor/cache/state_machine-1.2.0.gem
+homepage: ''
+licenses:
+- Commercial
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Library that gives a basic framework to support networked RFID CV5600 reader
+test_files: []