em-modbus 0.1.0

data/lib/modbus/transaction/client.rb

@@ -0,0 +1,162 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'rubygems'
+require 'eventmachine'
+
+module Modbus
+  module Transaction
+
+    class Client < Base
+      include EM::Deferrable
+
+
+      def initialize(conn, timeout)
+        super conn
+        @timeout = timeout
+      end
+
+
+      # Try to decode a response ADU from some recevied bytes and handle the ADU if decoding was successful.
+      #
+      # @param buffer [String] The bytes received from the network.
+      # @param conn [Modbus::Connection::TCPClient] An EM connection object to work on.
+      # @return [true, false] True, if there where enough bytes in the buffer and decoding was successful.
+      #
+      def self.recv_adu(buffer, conn)
+        adu = Modbus::TCPADU.new
+
+        if adu.decode :response, buffer, conn
+          transaction = conn.pick_pending_transaction adu.transaction_ident
+          fail ClientError, "Transaction ident #{adu.transaction_ident} not found!" unless transaction
+          transaction.handle_response adu
+          return true
+        else
+          return false
+        end
+      end
+
+
+      # Sends a request for the modbus function "read input status" asynchronusly. This method is non-blocking.
+      #
+      # @param start_addr [Integer] The starting modbus register address to read registers from.
+      # @param bit_count [Integer] The number of input bits to read.
+      #
+      def read_input_status(start_addr, bit_count)
+        pdu            = PDU::ReadInputStatusRequest.new
+        pdu.start_addr = start_addr
+        pdu.bit_count  = bit_count
+
+        send_pdu pdu
+      end
+
+
+      # Sends a request for the modbus function "read holding registers" asynchronusly. This method is non-blocking.
+      #
+      # @param start_addr [Integer] The starting modbus register address to read registers from.
+      # @param reg_count [Integer] The number of registers to read.
+      #
+      def read_holding_registers(start_addr, reg_count)
+        pdu            = PDU::ReadHoldingRegistersRequest.new
+        pdu.start_addr = start_addr
+        pdu.reg_count  = reg_count
+
+        send_pdu pdu
+      end
+
+
+      # Sends a request for the modbus function "write mutliple registers" asynchronusly. This method is non-blocking.
+      #
+      # @param start_addr [Integer] The starting modbus register address to read registers from.
+      # @param reg_values [Integer] The register values to write.
+      #
+      def write_multiple_registers(start_addr, reg_values)
+        pdu            = PDU::WriteMultipleRegistersRequest.new
+        pdu.start_addr = start_addr
+        pdu.reg_values = reg_values
+
+        send_pdu pdu
+      end
+
+
+      # Constructs a ADU using a PDU and send it asynchronusly to the server.
+      # The created ADU is stored internally and is matched to the response when the response is available.
+      #
+      # @param pdu [Modbus::PDU] The PDU to send.
+      # @return [Modbus::TCPADU] The sent ADU.
+      #
+      def send_pdu(pdu)
+        @request_adu = TCPADU.new pdu, @conn.next_transaction_ident
+        @conn.track_transaction self
+        @conn.send_data @request_adu.encode
+
+        @timeout_timer = EM.add_timer @timeout do
+          @conn.pick_pending_transaction @request_adu.transaction_ident
+          set_deferred_failure "Timeout #{@timeout}s expired"
+        end
+
+        self
+      end
+
+
+      # Handles a recevied ADU and calls the relevant callback.
+      # The corresponding request ADU is matched and cleaned up.
+      #
+      # @param adu [Modbus::ADU] The ADU to handle.
+      #
+      def handle_response(adu)
+        @response_adu = adu
+        fail Modbus.find_exception(@response_adu.pdu.exception_code), "Request PDU: #{@request_adu.pdu.inspect}" if @response_adu.pdu.is_a? PDU::Exception
+
+        transaction = TRANSACTIONS.find { |t| @response_adu.pdu.is_a? t[:response] }
+        fail "Unknown PDU #{@response_adu.pdu.inspect}" unless transaction
+        fail "Unexpected last sent PDU: #{@request_adu.pdu.inspect}" unless @request_adu.pdu.is_a? transaction[:request]
+
+        value = send transaction[:handler]
+        EM.cancel_timer @timeout_timer
+        set_deferred_success @request_adu.pdu.start_addr, value
+
+      rescue => e
+        set_deferred_failure "#{e.class} - #{e.message}"
+      end
+
+
+      def handle_read_input_status
+        @response_adu.pdu.bit_values
+      end
+
+
+      def handle_read_holding_registers
+        @response_adu.pdu.reg_values
+      end
+
+
+      def handle_write_multiple_registers
+        @response_adu.pdu.reg_count
+      end
+
+
+      # Returns the transaction ident of this transaction which is consistent to the ident of the request PDU.
+      #
+      # @return [Integer] The transaction ident.
+      #
+      def transaction_ident
+        @request_adu.transaction_ident
+      end
+
+
+      # Returns the duration of a transaction.
+      #
+      # @return [Float] Time time in seconds.
+      #
+      def transaction_time
+        fail ClientError, 'Response ADU unknown. Can not calcluate transaction time.' unless @response_adu
+        ((@response_adu.pdu.creation_time - @request_adu.pdu.creation_time) * 1000).round
+      end
+
+    end # Base
+
+  end # Request
+
+end # Modbus
+

data/lib/modbus/transaction/server.rb

@@ -0,0 +1,95 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+  module Transaction
+
+    class Server < Base
+
+
+      # Try to decode a response ADU from some recevied bytes and handle the ADU if decoding was successful.
+      #
+      # @param buffer [String] The bytes received from the network.
+      # @param conn [Modbus::Connection::TCPServer] An EM connection object to work on.
+      # @return [true, false] True, if there where enough bytes in the buffer and decoding was successful.
+      #
+      def self.recv_adu(buffer, conn)
+        adu = Modbus::TCPADU.new
+
+        if adu.decode :request, buffer, conn
+          transaction = self.new conn
+          transaction.handle_request adu
+          return true
+        else
+          return false
+        end
+      end
+
+
+      # Constructs a ADU using a PDU and send it asynchronusly to the server.
+      # The created ADU is stored internally and is matched to the response when the response is available.
+      #
+      # @param pdu [Modbus::PDU] The PDU to send.
+      # @return [Modbus::TCPADU] The sent ADU.
+      #
+      def send_pdu(pdu)
+        @response_adu = TCPADU.new pdu, @request_adu.transaction_ident
+        @conn.send_data @response_adu.encode
+        self
+      end
+
+
+      # Handles a recevied ADU and calls the relevant callback.
+      # The corresponding request ADU is matched and cleaned up.
+      #
+      # @param adu [Modbus::ADU] The ADU to handle.
+      #
+      def handle_request(adu)
+        @request_adu = adu
+
+        transaction = TRANSACTIONS.find { |t| adu.pdu.is_a? t[:request] }
+        fail IllegalFunction,     "Unknown PDU #{adu.pdu.inspect}" unless transaction
+        fail ServerDeviceFailure, "Unexpected last sent PDU: #{@request_adu.pdu.inspect}" unless @request_adu.pdu.is_a? transaction[:request]
+
+        pdu = send transaction[:handler]
+        send_pdu pdu
+
+      rescue ModbusError => error
+        send_pdu PDU::Exception.create(adu.pdu.func_code, error)
+      end
+
+
+      def handle_read_input_registers
+        read_registers 30001, PDU::ReadInputRegistersResponse
+      end
+
+
+      def handle_read_holding_registers
+        read_registers 40001, PDU::ReadHoldingRegistersResponse
+      end
+
+
+      def read_registers(offset, response_class)
+        reg_values     = @conn.read_registers offset + @request_adu.pdu.start_addr, @request_adu.pdu.reg_count
+        pdu            = response_class.new
+        pdu.reg_values = reg_values
+        pdu
+      end
+
+
+      def handle_write_multiple_registers
+        reg_count      = @conn.write_registers 40001 + @request_adu.pdu.start_addr, @request_adu.pdu.reg_values
+        pdu            = PDU::WriteMultipleRegistersResponse.new
+        pdu.start_addr = @request_adu.pdu.start_addr
+        pdu.reg_count  = reg_count
+        pdu
+      end
+
+
+    end # Server
+
+  end # Transaction
+end # Modbus
+
+

data/lib/modbus/transaction/transaction.rb

@@ -0,0 +1,39 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+require 'modbus/transaction/base'
+require 'modbus/transaction/client'
+require 'modbus/transaction/server'
+
+module Modbus
+  module Transaction
+
+    # Valid transactions (messages) and value handler config
+    TRANSACTIONS = [
+      {
+        :request  => PDU::ReadInputStatusRequest,
+        :response => PDU::ReadInputStatusResponse,
+        :handler  => :handle_read_input_status
+      },
+      {
+        :request  => PDU::ReadInputRegistersRequest,
+        :response => PDU::ReadInputRegistersResponse,
+        :handler  => :handle_read_input_registers
+      },
+      {
+        :request  => PDU::ReadHoldingRegistersRequest,
+        :response => PDU::ReadHoldingRegistersResponse,
+        :handler  => :handle_read_holding_registers
+      },
+      {
+        :request  => PDU::WriteMultipleRegistersRequest,
+        :response => PDU::WriteMultipleRegistersResponse,
+        :handler  => :handle_write_multiple_registers
+      }
+    ]
+
+  end # Transaction
+
+end # Modbus
+
+

data/lib/modbus/version.rb

@@ -0,0 +1,7 @@
+# Copyright © 2016 Andy Rohr <andy.rohr@mindclue.ch>
+# All rights reserved.
+
+
+module Modbus
+  VERSION = '0.1.0'
+end

data/lib/modbus.rb

@@ -0,0 +1,2 @@
+require 'modbus/version'
+require 'modbus/modbus'

data/spec/adi_spec.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require 'modbus'
+
+describe Modbus do
+
+  describe Modbus::Transaction do
+    it 'should do something' do
+
+
+
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'modbus'

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: em-modbus
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andy Rohr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2017-07-28 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  prerelease: false
+  name: eventmachine
+- !ruby/object:Gem::Dependency 
+  type: :development
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 6
+        version: "1.6"
+  requirement: *id002
+  prerelease: false
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  type: :development
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+  prerelease: false
+  name: rake
+- !ruby/object:Gem::Dependency 
+  type: :development
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  prerelease: false
+  name: rspec
+description: Ruby implementation of the Modbus protocol.
+email: 
+- andy.rohr@mindclue.ch
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- em-modbus.gemspec
+- examples/client.rb
+- examples/client_batch.rb
+- examples/server.rb
+- lib/modbus.rb
+- lib/modbus/adu/adu.rb
+- lib/modbus/adu/rtu_adu.rb
+- lib/modbus/adu/tcp_adu.rb
+- lib/modbus/client.rb
+- lib/modbus/connection/base.rb
+- lib/modbus/connection/connection.rb
+- lib/modbus/connection/protocol_data.rb
+- lib/modbus/connection/tcp_client.rb
+- lib/modbus/connection/tcp_server.rb
+- lib/modbus/exceptions.rb
+- lib/modbus/modbus.rb
+- lib/modbus/pdu/exception.rb
+- lib/modbus/pdu/pdu.rb
+- lib/modbus/pdu/read_holding_registers.rb
+- lib/modbus/pdu/read_input_registers.rb
+- lib/modbus/pdu/read_input_status.rb
+- lib/modbus/pdu/read_registers.rb
+- lib/modbus/pdu/write_multiple_registers.rb
+- lib/modbus/register/base.rb
+- lib/modbus/register/bit_register.rb
+- lib/modbus/register/register.rb
+- lib/modbus/register/word_register.rb
+- lib/modbus/server.rb
+- lib/modbus/transaction/base.rb
+- lib/modbus/transaction/client.rb
+- lib/modbus/transaction/server.rb
+- lib/modbus/transaction/transaction.rb
+- lib/modbus/version.rb
+- spec/adi_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/arohr/em-modbus
+licenses: 
+- MPLv2
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.29
+signing_key: 
+specification_version: 3
+summary: Modbus Client and Server for eventmachine.
+test_files: 
+- spec/adi_spec.rb
+- spec/spec_helper.rb