plc_access 0.1.0

data/lib/plc_access/protocol/mitsubishi/fx_protocol.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 ITO SOFT DESIGN Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module PlcAccess
+  module Protocol
+    module Mitsubishi
+      class FxProtocol < Protocol
+        attr_accessor :pc_no, :baudrate, :station_no, :wait_time
+
+        STX = "\u0002"
+        ETX = "\u0003"
+        EOT = "\u0004"
+        ENQ = "\u0005"
+        ACK = "\u0006"
+        LF  = "\u000a"
+        CR  = "\u000d"
+        NAK = "\u0015"
+
+        DELIMITER = "\r\n"
+
+        def initialize(options = {})
+          super
+          @port = options[:port] || `ls /dev/tty.usb*`.split("\n").map(&:chomp).first
+          @pc_no = 0xff
+          @baudrate = 19_200
+          @station_no = 0
+          @wait_time = 0
+          @comm = nil
+        end
+
+        def open
+          open!
+        rescue StandardError
+          nil
+        end
+
+        def open!
+          return false unless @port
+
+          begin
+            # port, baudrate, bits, stop bits, parity(0:none, 1:even, 2:odd)
+            @comm ||= SerialPort.new(@port, @baudrate, 7, 1, 2).tap do |s|
+              s.read_timeout = (TIMEOUT * 1000.0).to_i
+            end
+            raise StandardError.new("invalid port #{@port}") unless @comm
+          rescue StandardError => e
+            p e
+            nil
+          end
+        end
+
+        def close
+          @comm&.close
+          @comm = nil
+        end
+
+        def get_bits_from_device(count, device)
+          unless available_bits_range.include? count
+            raise ArgumentError,
+                  "A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = body_for_get_bits_from_device(count, device) + DELIMITER
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @comm.write(packet)
+          @comm.flush
+          res = receive
+          bits = []
+
+          if res && (check_sum(res[0..-5]) == res[-4, 2])
+            bits =
+              res[5..-6].each_char.map do |c|
+                c == '1'
+              end
+          end
+          @logger.debug("> #{dump_packet ack_packet}")
+          @comm.write(ack_packet)
+          @logger.debug("get #{device.name} => #{bits}")
+
+          bits
+        end
+
+        def set_bits_to_device(bits, device)
+          unless available_bits_range.include? bits.size
+            raise ArgumentError,
+                  "A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = body_for_set_bits_to_device(bits, device)
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @comm.write(packet)
+          @comm.flush
+          res = receive
+          @logger.debug("set #{bits} to:#{device.name}")
+
+          # error checking
+          raise "ERROR: return #{res} for set_bits_to_device(#{bits}, #{device.name})" unless res == ack_packet
+        end
+
+        def get_words_from_device(count, device)
+          unless available_words_range.include? count
+            raise ArgumentError,
+                  "A count #{count} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = body_for_get_words_from_device(count, device) + DELIMITER
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @comm.write(packet)
+          @comm.flush
+          res = receive
+          words = []
+
+          if res && (check_sum(res[0..-5]) == res[-4, 2])
+            words =
+              res[5..-6].scan(/.{4}/).map do |v|
+                v.to_i(16)
+              end
+          end
+          @logger.debug("> #{dump_packet ack_packet}")
+          @comm.write(ack_packet)
+          @logger.debug("get #{device.name} => #{words}")
+
+          words
+        end
+
+        def set_words_to_device(words, device)
+          unless available_bits_range.include? words.size
+            raise ArgumentError,
+                  "A count of words #{words.size} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = body_for_set_words_to_device(words, device)
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @comm.write(packet)
+          @comm.flush
+          res = receive
+          @logger.debug("set #{words} to: #{device.name}")
+
+          # error checking
+          raise "ERROR: return #{res} for set_bits_to_device(#{words}, #{device.name})" unless res == ack_packet
+        end
+
+        def device_by_name(name)
+          case name
+          when String
+            d = FxDevice.new name
+            d.valid? ? d : nil
+          else
+            # it may be already QDevice
+            name
+          end
+        end
+
+        def receive
+          res = ''
+          begin
+            Timeout.timeout(TIMEOUT) do
+              res = @comm.gets
+            end
+            res
+          rescue Timeout::Error
+            puts "*** ERROR: TIME OUT : #{res} ***"
+          end
+          @logger.debug("< #{dump_packet res}")
+          res
+        end
+
+        def available_bits_range(_device = nil)
+          1..256
+        end
+
+        def available_words_range(_device = nil)
+          1..64
+        end
+
+        def body_for_get_bit_from_deivce(device)
+          body_for_get_bits_from_device 1, device
+        end
+
+        def body_for_get_bits_from_device(count, device)
+          body = header_with_command 'BR'
+          body += "#{device.name}#{count.to_s(16).rjust(2, '0')}"
+          body += check_sum(body)
+          body += DELIMITER
+          body.upcase
+        end
+
+        def body_for_get_words_from_device(count, device)
+          body = header_with_command 'WR'
+          body += "#{device.name}#{count.to_s(16).rjust(2, '0')}"
+          body += check_sum(body)
+          body += DELIMITER
+          body.upcase
+        end
+
+        def body_for_set_bits_to_device(bits, device)
+          body = header_with_command 'BW'
+          body += "#{device.name}#{bits.count.to_s(16).rjust(2, '0')}"
+          body += bits.map { |b| b ? '1' : '0' }.join('')
+          body += check_sum(body)
+          body += DELIMITER
+          body.upcase
+        end
+        alias body_for_set_bit_to_device body_for_set_bits_to_device
+
+        def body_for_set_words_to_device(words, device)
+          body = header_with_command 'WW'
+          body += "#{device.name}#{words.count.to_s(16).rjust(2, '0')}"
+          body += words.map { |w| w.to_s(16).rjust(4, '0') }.join('')
+          body += check_sum(body)
+          body += DELIMITER
+          body.upcase
+        end
+
+        def dump_packet(packet)
+          packet.inspect
+        end
+
+        private
+
+        def check_sum(packet)
+          packet[1..].upcase.unpack('C*').inject(0) { |s, c| s + c }.to_s(16).rjust(2, '0')[-2, 2].upcase
+        end
+
+        def header_with_command(command)
+          "#{ENQ}#{station_no.to_s.rjust(2, '0')}#{pc_no.to_s(16).rjust(2, '0')}#{command}#{wait_time}".upcase
+        end
+
+        def ack_packet
+          "#{ACK}#{station_no.to_s.rjust(2, '0')}#{pc_no.to_s(16).rjust(2, '0')}#{DELIMITER}".upcase
+        end
+      end
+    end
+  end
+end

data/lib/plc_access/protocol/mitsubishi/mc_protocol.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 ITO SOFT DESIGN Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module PlcAccess
+  module Protocol
+    module Mitsubishi
+      class McProtocol < Protocol
+        def initialize(options = {})
+          super
+          @socket = nil
+          @host = options[:host] || '192.168.0.10'
+          @port = options[:port] || 5010
+        end
+
+        def open
+          open!
+        rescue StandardError
+          nil
+        end
+
+        def open!
+          @socket ||= TCPSocket.open(@host, @port)
+        end
+
+        def close
+          @socket&.close
+          @socket = nil
+        end
+
+        def get_bits_from_device(count, device)
+          unless available_bits_range.include? count
+            raise ArgumentError,
+                  "A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = make_packet(body_for_get_bits_from_device(count, device))
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @socket.write(packet.pack('C*'))
+          @socket.flush
+          res = receive
+
+          # error checking
+          end_code = res[9, 2].pack('C*').unpack1('v')
+          unless end_code.zero?
+            error = res[11, 2].pack('C*').unpack1('v')
+            raise "return end code 0x#{end_code.to_s(16)} error code 0x#{error.to_s(16)} for get_bits_from_device(#{count}, #{device.name})"
+          end
+
+          # get results
+          bits = []
+          count.times do |i|
+            v = res[11 + i / 2]
+            bits << if i.even?
+                      ((v >> 4) != 0)
+                    else
+                      ((v & 0xf) != 0)
+                    end
+          end
+          @logger.debug("get #{device.name} => #{bits}")
+          bits
+        end
+
+        def set_bits_to_device(bits, device)
+          unless available_bits_range.include? bits.size
+            raise ArgumentError,
+                  "A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = make_packet(body_for_set_bits_to_device(bits, device))
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @socket.write(packet.pack('C*'))
+          @socket.flush
+          res = receive
+          @logger.debug("set #{bits} to:#{device.name}")
+
+          # error checking
+          end_code = res[9, 2].pack('C*').unpack1('v')
+          unless end_code.zero?
+            error = res[11, 2].pack('C*').unpack1('v')
+            raise "return end code 0x#{end_code.to_s(16)} error code 0x#{error.to_s(16)} for set_bits_to_device(#{bits}, #{device.name})"
+          end
+        end
+
+        def get_words_from_device(count, device)
+          unless available_bits_range.include? count
+            raise ArgumentError,
+                  "A count #{count} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = make_packet(body_for_get_words_from_device(count, device))
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @socket.write(packet.pack('C*'))
+          @socket.flush
+          res = receive
+
+          # error checking
+          end_code = res[9, 2].pack('C*').unpack1('v')
+          unless end_code.zero?
+            error = res[11, 2].pack('C*').unpack1('v')
+            raise "return end code 0x#{end_code.to_s(16)} error code 0x#{error.to_s(16)} for get_words_from_device(#{count}, #{device.name})"
+          end
+
+          # get result
+          words = []
+          res[11, 2 * count].each_slice(2) do |pair|
+            words << pair.pack('C*').unpack1('v')
+          end
+          @logger.debug("get from: #{device.name} => #{words}")
+          words
+        end
+
+        def set_words_to_device(words, device)
+          unless available_bits_range.include? words.size
+            raise ArgumentError,
+                  "A count of words #{words.size} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}"
+          end
+
+          device = device_by_name device
+          packet = make_packet(body_for_set_words_to_device(words, device))
+          @logger.debug("> #{dump_packet packet}")
+          open
+          @socket.write(packet.pack('C*'))
+          @socket.flush
+          res = receive
+          @logger.debug("set #{words} to: #{device.name}")
+
+          # error checking
+          end_code = res[9, 2].pack('C*').unpack1('v')
+          unless end_code.zero?
+            error = res[11, 2].pack('C*').unpack1('v')
+            raise "return end code 0x#{end_code.to_s(16)} error code 0x#{error.to_s(16)} for set_words_to_device(#{words}, #{device.name})"
+          end
+        end
+
+        def device_by_name(name)
+          case name
+          when String
+            d = QDevice.new name
+            d.valid? ? d : nil
+          else
+            # it may be already QDevice
+            name
+          end
+        end
+
+        def receive
+          res = []
+          len = 0
+          begin
+            Timeout.timeout(TIMEOUT) do
+              loop do
+                c = @socket.read(1)
+                next if c.nil? || c == ''
+
+                res << c.bytes.first
+                len = res[7, 2].pack('C*').unpack1('v*') if res.length >= 9
+                break if len + 9 == res.length
+              end
+            end
+          rescue Timeout::Error
+            puts '*** ERROR: TIME OUT ***'
+          end
+          @logger.debug("< #{dump_packet res}")
+          res
+        end
+
+        def available_bits_range(_device = nil)
+          1..(960 * 16)
+        end
+
+        def available_words_range(_device = nil)
+          1..960
+        end
+
+        private
+
+        def make_packet(body)
+          header = [0x50, 0x00, 0x00, 0xff, 0xff, 0x03, 0x00, 0x00, 0x00, 0x10, 0x00]
+          header[7..8] = data_for_short(body.length + 2)
+          header + body
+        end
+
+        def body_for_get_bit_from_deivce(device)
+          body_for_get_bits_from_device 1, device
+        end
+
+        def body_for_get_bits_from_device(count, device)
+          body_for_get_words_from_device count, device, false
+        end
+
+        def body_for_get_words_from_device(count, device, word = true)
+          body = [0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00]
+          body[2] = 1 unless word
+          body[4..7] = data_for_device(device)
+          body[8..9] = data_for_short count
+          body
+        end
+
+        def body_for_set_bits_to_device(bits, device)
+          body = [0x01, 0x14, 0x01, 0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00]
+          d = device
+          bits = [bits] unless bits.is_a? Array
+          bits.each_slice(2) do |pair|
+            body << (pair.first ? 0x10 : 0x00)
+            body[-1] |= (pair.last ? 0x1 : 0x00) if pair.size == 2
+            d = d.next_device
+          end
+          body[4..7] = data_for_device(device)
+          body[8..9] = data_for_short bits.size
+          body
+        end
+        alias body_for_set_bit_to_device body_for_set_bits_to_device
+
+        def body_for_set_words_to_device(words, device)
+          body = [0x01, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00]
+          d = device
+          words = [words] unless words.is_a? Array
+          words.each do |v|
+            body += data_for_short v
+            d = d.next_device
+          end
+          body[4..7] = data_for_device(device)
+          body[8..9] = data_for_short words.size
+          body
+        end
+
+        def data_for_device(device)
+          a = data_for_int device.number
+          a[3] = device.suffix_code
+          a
+        end
+
+        def data_for_short(value)
+          [value].pack('v').unpack('C*')
+        end
+
+        def data_for_int(value)
+          [value].pack('V').unpack('C*')
+        end
+
+        def dump_packet(packet)
+          a = []
+          len = packet.length
+          bytes = packet.dup
+          len.times do |i|
+            a << "0#{bytes[i].to_s(16)}"[-2, 2]
+          end
+          "[#{a.join(', ')}]"
+        end
+      end
+    end
+  end
+end

data/lib/plc_access/protocol/mitsubishi/mitsubishi.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 ITO SOFT DESIGN Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'socket'
+require 'logger'
+require 'timeout'
+
+require 'qdevice'
+require 'mc_protocol'
+
+require 'fx_device'
+require 'fx_protocol'

data/lib/plc_access/protocol/mitsubishi/qdevice.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# The MIT License (MIT)
+#
+# Copyright (c) 2016 ITO SOFT DESIGN Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module PlcAccess
+  module Protocol
+    module Mitsubishi
+      class QDevice < PlcDevice
+        attr_reader :suffix, :number
+
+        SUFFIXES = %w[SM SD X Y M L F V B D W TS TC TN SS SC SN CS CC CN SB SW S DX DY Z R ZR].freeze
+        SUFFIX_CODES = [0x91, 0xa9, 0x9c, 0x9d, 0x90, 0x92, 0x93, 0x94, 0xa0, 0xa8, 0xb4, 0xc1, 0xc0, 0xc2, 0xc7, 0xc6,
+                        0xc8, 0xc4, 0xc3, 0xc5, 0xa1, 0xb5, 0x98, 0xa2, 0xa3, 0xcc, 0xaf, 0xb0].freeze
+
+        def initialize(a, b = nil)
+          case a
+          when Array
+            case a.size
+            when 4
+              @suffix = suffix_for_code(a[3])
+              @number = ((a[2] << 8 | a[1]) << 8) | a[0]
+            end
+          when String
+            if b
+              @suffix = a.upcase
+              @number = b
+            elsif a.length == 12
+              @suffix = [a[0, 2].to_i(16), a[2, 2].to_i(16)].pack 'C*'
+              @suffix.strip!
+              @number = a[4, 8].to_i(16)
+            elsif /(X|Y|B|W|SB|SW|DX|DY)([0-9a-f]+)/i =~ a
+              @suffix = ::Regexp.last_match(1).upcase
+              @number = ::Regexp.last_match(2).to_i(p_adic_number)
+            elsif /(M|L|S|F|T|C|D|R|ZR)([0-9]+)/i =~ a
+              @suffix = ::Regexp.last_match(1).upcase
+              @number = ::Regexp.last_match(2).to_i(p_adic_number)
+            end
+          end
+        end
+
+        def valid?
+          !!@suffix && !!@number
+        end
+
+        def p_adic_number
+          case @suffix
+          when 'X', 'Y', 'B', 'W', 'SB', 'SW', 'DX', 'DY'
+            16
+          else
+            10
+          end
+        end
+
+        def name
+          @suffix + @number.to_s(p_adic_number).upcase
+        end
+
+        def next_device
+          self.class.new @suffix, @number + 1
+        end
+
+        def bit_device?
+          case @suffix
+          when 'SM', 'X', 'Y', 'M', 'L', 'F', 'V', 'B',
+               'TS', 'TC', 'SS', 'SC', 'CS', 'CC', 'SB', 'S', 'DX', 'DY'
+            true
+          else
+            false
+          end
+        end
+
+        def suffix_for_code(code)
+          index = SUFFIX_CODES.index code
+          index ? SUFFIXES[index] : nil
+        end
+
+        def suffix_code
+          index = SUFFIXES.index suffix
+          index ? SUFFIX_CODES[index] : 0
+        end
+
+        def +(other)
+          self.class.new suffix, number + other
+        end
+
+        def -(other)
+          self.class.new suffix, [number - other, 0].max
+        end
+      end
+    end
+  end
+end