ladder_drive 0.5.2 → 0.6.0

data/lib/ladder_drive/asm.rb

@@ -34,10 +34,17 @@ module LadderDrive
     def initialize source, endian = nil
       @endian = endian || BIG_ENDIAN
       @lines = []
+      line_no = 1
       address = 0
       source.each_line do |line|
-        @lines << AsmLine.new(line, address, @endian)
-        address = @lines.last.next_address
+        begin
+          @lines << AsmLine.new(line, address, @endian)
+          address = @lines.last.next_address
+          line_no += 1
+        rescue SyntaxError => e
+          puts "#{e.class}: line:#{line_no}; #{line.chomp}; #{e.to_s} "
+          throw
+        end
       end
     end
 
@@ -113,7 +120,7 @@ module LadderDrive
           @codes << encode_mnemonic(mnemonic)
           case operand_type(mnemonic)
           when OPERAND_TYPE_TYPE_AND_NUMBER
-            @codes += parse_type_and_number(operand1)
+            @codes += parse_type_and_number(mnemonic, operand1, operand2)
           end
         end
       end
@@ -166,7 +173,7 @@ EOB
         mnemonic_dict[mnemonic]
       end
 
-      def parse_type_and_number operand
+      def parse_type_and_number mnemonic, operand, value
         /([[:alpha:]]*)(\d+[0-9A-Fa-f]*)\.?(\d*)?/ =~ operand
         suffix = $1
         number = $2
@@ -189,15 +196,63 @@ EOB
         end
 
         if number < 256
-          [type_code, number]
+          codes = [type_code, number]
         else
           case endian
           when Asm::LITTLE_ENDIAN
-            [type_code | 0x10, number & 0xff, (number & 0xff00) >> 8]
+            codes = [type_code | 0x10, number & 0xff, (number & 0xff00) >> 8]
           when Asm::BIG_ENDIAN
-            [type_code | 0x10, (number & 0xff00) >> 8, number & 0xff]
+            codes = [type_code | 0x10, (number & 0xff00) >> 8, number & 0xff]
+          end
+        end
+
+        # If mnemonic is out/outi and device type is timer or counter, append time or count.
+        case mnemonic
+        when /OUT/
+          case suffix
+          when 'T'
+            codes += time_value(value)
+          when 'C'
+            codes += counter_value(value)
           end
         end
+
+        codes
+      end
+
+      def time_value value
+        raise SyntaxError.new "It must be required time value." unless /^\d*\.?\d*$/ =~ value
+
+        t = value.to_f
+        g = 0
+        codes = []
+        while t < 16384 && g <= 3
+          t *= 10.0
+          g += 1
+        end
+        t /= 10.0
+        g -= 1
+        v = (g << 14) | t.to_i
+
+        case endian
+        when Asm::LITTLE_ENDIAN
+          codes = [v & 0xff, (v & 0xff00) >> 8]
+        when Asm::BIG_ENDIAN
+          codes = [(v & 0xff00) >> 8, v & 0xff]
+        end
+        codes #rdlsf@de
+      end
+
+      def counter_value value
+        raise SyntaxError.new "It must be required count value." unless /^\d+$/ =~ value
+
+        v = value.to_i
+        case endian
+        when Asm::LITTLE_ENDIAN
+          codes = [v & 0xff, (v & 0xff00) >> 8]
+        when Asm::BIG_ENDIAN
+          codes = [(v & 0xff00) >> 8, v & 0xff]
+        end
       end
 
   end

data/lib/ladder_drive/cli.rb

@@ -51,5 +51,16 @@ module LadderDrive
       puts "#{name} was successfully created."
     end
 
+    desc "plugin", "Install the specified plugin."
+    def plugin(name)
+      root_dir = File.expand_path(File.join(File.dirname(__FILE__), "..", ".."))
+      plugins_path = File.join(root_dir, "plugins")
+      path = File.join(plugins_path, "#{name}_plugin.rb")
+      if File.exist? path
+        mkdir_p "plugins"
+        cp path, "plugins/#{name}_plugins.rb"
+      end
+    end
+
   end
 end

data/lib/ladder_drive/plc_device.rb

@@ -99,9 +99,14 @@ module LadderDrive
       end
     end
 
+    # NOTE: override at subclass
+    #       It should get from plc
+    def device_by_suffix_number suffix, number
+      self.class.new suffix, number
+    end
+
     def next_device
-      d = self.class.new @suffix, @number + 1
-      d
+      device_by_suffix_number @suffix, @number + 1
     end
 
     def bit_device?
@@ -109,11 +114,11 @@ module LadderDrive
     end
 
     def + value
-      self.class.new self.suffix, self.number + value
+      device_by_suffix_number self.suffix, self.number + value
     end
 
     def - value
-      self.class.new self.suffix, [self.number - value, 0].max
+      device_by_suffix_number self.suffix, [self.number - value, 0].max
     end
 
     def input?
@@ -132,6 +137,30 @@ module LadderDrive
     alias :word :value
     alias :word= :value=
 
+    def text len=8
+      n = (len + 1) / 2
+      d = self
+      a = []
+      n.times{ a << d.value; d = d.next_device}
+      s = a.pack("n*").split("\x00").first
+      s ? s[0,len] : ""
+    end
+
+    def set_text value, len=8
+      value = value[0, len]
+      value << "\00" unless value.length % 2 == 0
+      a = value.unpack("n*")
+      d = self
+      a.each do |v|
+        d.value = v
+        d = d.next_device
+      end
+    end
+
+    def text= value
+      set_text value
+    end
+
     def device_code
       ESC_SUFFIXES.index @suffix
     end

data/lib/ladder_drive/protocol/mitsubishi/fx_device.rb

@@ -0,0 +1,14 @@
+module LadderDrive
+module Protocol
+module Mitsubishi
+
+  class FxDevice < QDevice
+    
+    def name
+      @suffix + @number.to_s.rjust(4, "0")
+    end
+  end
+
+end
+end
+end

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

@@ -0,0 +1,330 @@
+# 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 LadderDrive
+module Protocol
+module Mitsubishi
+
+  class FxProtocol < Protocol
+
+    attr_accessor :pc_no
+    attr_accessor :baudrate
+    attr_accessor :station_no
+    attr_accessor :wait_time
+
+    STX = "\u0002"
+    ETX = "\u0003"
+    EOT = "\u0004"
+    ENQ = "\u0005"
+    ACK = "\u0006"
+    LF  = "\u000a"
+    CR  = "\u000d"
+    NAK = "\u0015"
+
+    DELIMITER = "\r\n"
+    TIMEOUT = 1.0
+
+    def initialize options={}
+      super
+      @port = options[:port] || `ls /dev/tty.usb*`.split("\n").map{|l| l.chomp}.first
+      @pc_no = 0xff
+      @baudrate = 19200
+      @station_no = 0
+      @wait_time = 0
+      #prepare_device_map
+    end
+
+    def open
+      open!
+    rescue
+      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
+      rescue => e
+        p e
+        nil
+      end
+    end
+
+    def close
+      @comm.close if @comm
+      @comm = nil
+    end
+
+    def get_bit_from_device device
+      device = device_by_name device
+      get_bits_from_device(1, device).first
+    end
+
+    def get_bits_from_device count, device
+      raise ArgumentError.new("A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}") unless available_bits_range.include? count
+
+      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
+        if check_sum(res[0..-5]) == res[-4,2]
+          bits =
+            res[5..-6].each_char.map do |c|
+              c == "1" ? true : false
+            end
+        else
+        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
+      raise ArgumentError.new("A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}") unless available_bits_range.include? bits.size
+
+      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
+      unless res == ack_packet
+        raise "ERROR: return #{res} for set_bits_to_device(#{bits}, #{device.name})"
+      end
+    end
+
+    def get_word_from_device device
+      device = device_by_name device
+      get_words_from_device(1, device).first
+    end
+
+    def get_words_from_device(count, device)
+      raise ArgumentError.new("A count #{count} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}") unless available_words_range.include? count
+
+      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
+        if check_sum(res[0..-5]) == res[-4,2]
+          words =
+            res[5..-6].scan(/.{4}/).map do |v|
+              v.to_i(16)
+            end
+        else
+        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
+      raise ArgumentError.new("A count of words #{words.size} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}") unless available_bits_range.include? words.size
+
+      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
+      unless res == ack_packet
+        raise "ERROR: return #{res} for set_bits_to_device(#{words}, #{device.name})"
+      end
+    end
+
+    def device_by_name name
+      case name
+      when String
+        FxDevice.new name
+      when EscDevice
+        local_device_of name
+      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
+
+
+=begin
+    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
+=end
+
+    def dump_packet packet
+      packet.inspect
+    end
+
+=begin
+    def prepare_device_map
+      @conv_dev_dict ||= begin
+        h = {}
+        [
+          ["X", "X0", 1024],
+          ["Y", "Y0", 1024],
+          ["M", "M0", 1024],
+          ["C", "C0", 256],
+          ["T", "T0", 256],
+          ["L", "L0", 1024],
+          ["SC", "M1024", 1024],
+          ["D", "D0", 1024],
+          ["H", "D1024", 1024],
+          ["SD", "D2048", 1024],
+          ["PRG", "D3072", 1024]    # ..D4095
+        ].each do |s,d,c|
+          h[s] = [QDevice.new(d), c]
+        end
+        h
+      end
+    end
+=end
+
+=begin
+    def local_device_of device
+      return device if device.is_a? QDevice
+      d, c = @conv_dev_dict[device.suffix]
+      return nil unless device.number < c
+      ld = QDevice.new(d.suffix, d.number + device.number)
+      device_by_name ld.name
+    end
+=end
+
+    private
+
+      def check_sum packet
+        packet[1..-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.to_s}".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/ladder_drive/protocol/mitsubishi/mc_protocol.rb

@@ -58,7 +58,7 @@ module Mitsubishi
       raise ArgumentError.new("A count #{count} must be between #{available_bits_range.first} and #{available_bits_range.last} for #{__method__}") unless available_bits_range.include? count
 
       device = device_by_name device
-      packet = make_packet(body_for_get_bits_from_deivce(count, device))
+      packet = make_packet(body_for_get_bits_from_device(count, device))
       @logger.debug("> #{dump_packet packet}")
       open
       @socket.write(packet.pack("C*"))
@@ -116,7 +116,7 @@ module Mitsubishi
       raise ArgumentError.new("A count #{count} must be between #{available_words_range.first} and #{available_words_range.last} for #{__method__}") unless available_bits_range.include? count
 
       device = device_by_name device
-      packet = make_packet(body_for_get_words_from_deivce(count, device))
+      packet = make_packet(body_for_get_words_from_device(count, device))
       @logger.debug("> #{dump_packet packet}")
       open
       @socket.write(packet.pack("C*"))
@@ -211,14 +211,14 @@ module Mitsubishi
     end
 
     def body_for_get_bit_from_deivce device
-      body_for_get_bits_from_deivce 1, device
+      body_for_get_bits_from_device 1, device
     end
 
-    def body_for_get_bits_from_deivce count, device
-      body_for_get_words_from_deivce count, device, false
+    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_deivce count, device, word = true
+    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)

data/lib/ladder_drive/protocol/mitsubishi/mitsubishi.rb

@@ -26,5 +26,9 @@ $:.unshift File.dirname(__FILE__)
 require 'socket'
 require 'logger'
 require 'timeout'
+
 require 'qdevice'
 require 'mc_protocol'
+
+require 'fx_device'
+require 'fx_protocol'

data/lib/ladder_drive/protocol/protocol.rb

@@ -189,6 +189,7 @@ module Protocol
 end
 end
 
+require 'serialport'
 require 'keyence/keyence'
 # Use load instead require, because there are two emulator files.
 load File.join(dir, 'emulator/emulator.rb')

data/lib/ladder_drive/version.rb

@@ -22,5 +22,5 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 module LadderDrive
-  VERSION = "0.5.2"
+  VERSION = "0.6.0"
 end

data/lib/plc/emulator/emu_device.rb

@@ -57,6 +57,13 @@ module Emulator
       @changed
     end
 
+    # NOTE: override at subclass
+    #       It should get from plc
+    def device_by_suffix_number suffix, number
+      d = super
+      plc.device_by_name d.name
+    end
+
     def value= value
       set_value value
     end

data/lib/plc/emulator/emu_plc.rb

@@ -22,14 +22,18 @@
 
 require 'ladder_drive/plc_device'
 require 'yaml'
+require 'plc_plugins'
 
 include LadderDrive
 
 module Plc
 module Emulator
 
+
   class EmuPlc
 
+    include PlcPlugins
+
     attr_accessor :program_data
     attr_reader :program_pointer
     attr_reader :config
@@ -60,6 +64,7 @@ module Emulator
       @lock = Mutex.new
       @config = config
       reset
+      load_plugins
     end
 
     def device_by_name name
@@ -120,6 +125,7 @@ module Emulator
       # Save must be executed berofe sync_output, because changed flag was clear after sync_output
       save
       sync_output
+      exec_plugins
     end
 
     def bool
@@ -557,8 +563,6 @@ EOB
       end
       def rst; set true; end
 
-
-
   end
 
 end

data/lib/plc/emulator/emu_plc_server.rb

@@ -53,14 +53,15 @@ module Emulator
         server = TCPServer.open @port
         puts "launching emulator ... "
         loop do
-          socket = server.accept
-          puts "done launching"
-          while line = socket.gets
-            begin
-              r = @plc.execute_console_commands line
-              socket.puts r
-            rescue => e
-              socket.puts "E0 #{e}\r\n"
+          Thread.start(server.accept) do |socket|
+            puts "done launching"
+            while line = socket.gets
+              begin
+                r = @plc.execute_console_commands line
+                socket.puts r
+              rescue => e
+                socket.puts "E0 #{e}\r\n"
+              end
             end
           end
         end