tp_plus 0.0.73

data/lib/tp_plus/nodes/posreg_node.rb

@@ -0,0 +1,48 @@
+module TPPlus
+  module Nodes
+    class PosregNode
+
+      COMPONENTS = {
+        "x" => 1,
+        "y" => 2,
+        "z" => 3,
+        "w" => 4,
+        "p" => 5,
+        "r" => 6
+      }
+
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{@comment}"
+      end
+
+      def component(m)
+        return "" if m == ""
+
+        ",#{COMPONENTS[m]}"
+      end
+
+      def component_valid?(c)
+        [""].concat(COMPONENTS.keys).include? c
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def eval(context,options={})
+        options[:method] ||= ""
+        raise "Invalid component" unless component_valid?(options[:method])
+
+        "PR[#{@id}#{component(options[:method])}#{comment_string}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/raise_node.rb

@@ -0,0 +1,13 @@
+module TPPlus
+  module Nodes
+    class RaiseNode
+      def initialize(target)
+        @target = target
+      end
+
+      def eval(context, options={})
+        "#{@target.eval(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/real_node.rb

@@ -0,0 +1,27 @@
+module TPPlus
+  module Nodes
+    class RealNode
+      def initialize(value)
+        @value = value
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def eval(context,options={})
+        val = if options[:as_string]
+          ("%.2f" % @value).sub(/^0/,'')
+        else
+          @value
+        end
+
+        if @value < 0
+          "(#{val})"
+        else
+          val
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/set_node.rb

@@ -0,0 +1,22 @@
+module TPPlus
+  module Nodes
+    class SetNode
+      def initialize(type, target, value)
+        @type   = type
+        @target = target
+        @value  = value
+      end
+
+      def eval(context)
+        case @type
+        when "set_uframe"
+          "UFRAME[#{@target.eval(context)}]=#{@value.eval(context)}"
+        when "set_skip_condition"
+          "SKIP CONDITION #{@value.eval(context, disable_mixed_logic: true)}"
+        else
+          raise "Unsupported FANUC setter"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/skip_node.rb

@@ -0,0 +1,22 @@
+module TPPlus
+  module Nodes
+    class SkipNode
+      def initialize(target, lpos_pr)
+        @target = target
+        @lpos_pr = lpos_pr
+      end
+
+      def lpos_pr(context)
+        return "" if @lpos_pr.nil?
+
+        ",#{@lpos_pr.eval(context)}=LPOS"
+      end
+
+      def eval(context)
+        raise "Label (#{@target}) not found" if context.labels[@target.to_sym].nil?
+
+        "Skip,LBL[#{context.labels[@target.to_sym]}]#{lpos_pr(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/speed_node.rb

@@ -0,0 +1,29 @@
+module TPPlus
+  module Nodes
+    class SpeedNode
+      def initialize(speed_hash)
+        @speed_hash = speed_hash
+      end
+
+      def speed(context)
+        @speed_hash[:speed].eval(context)
+      end
+
+      def units
+        case @speed_hash[:units]
+        when "mm/s"
+          "mm/sec"
+        else
+          @speed_hash[:units]
+        end
+      end
+
+
+      def eval(context)
+        return @speed_hash[:speed] if @speed_hash[:units].nil?
+
+        "#{speed(context)}#{units}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/string_node.rb

@@ -0,0 +1,13 @@
+module TPPlus
+  module Nodes
+    class StringNode
+      def initialize(s)
+        @s = s
+      end
+
+      def eval(context)
+        "'#{@s}'"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/string_register_node.rb

@@ -0,0 +1,25 @@
+module TPPlus
+  module Nodes
+    class StringRegisterNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def requires_mixed_logic?(context)
+        false
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{@comment}"
+      end
+
+      def eval(context,options={})
+        "SR[#{@id}#{comment_string}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/termination_node.rb

@@ -0,0 +1,18 @@
+module TPPlus
+  module Nodes
+    class TerminationNode
+      def initialize(value)
+        @value = value
+      end
+
+      def eval(context)
+        if @value.is_a? DigitNode
+          "CNT#{@value.eval(context)}"
+        else
+          # for registers
+          "CNT #{@value.eval(context)}"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/terminator_node.rb

@@ -0,0 +1,16 @@
+module TPPlus
+  module Nodes
+    class TerminatorNode
+      def eval(context)
+        nil
+      end
+    end
+  end
+end
+
+# IF R[1:foo]<>1,JMP LBL[100] ;
+# R[1:foo]=2 ;
+# JMP LBL[101] ;
+# LBL[100] ;
+# R[1:foo]=1 ;
+# LBL[101] ;

data/lib/tp_plus/nodes/time_node.rb

@@ -0,0 +1,24 @@
+module TPPlus
+  module Nodes
+    class TimeNode
+      def initialize(type, time, action)
+        @type = type
+        @time = time
+        @action = action
+      end
+
+      def type
+        case @type.downcase
+        when "time_before"
+          "TB"
+        when "time_after"
+          "TA"
+        end
+      end
+
+      def eval(context)
+        "#{type} #{@time.eval(context,as_string: true)}sec,#{@action.eval(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/timer_method_node.rb

@@ -0,0 +1,37 @@
+module TPPlus
+  module Nodes
+    class TimerMethodNode
+      def initialize(method, target)
+        @method = method
+        @target = target
+      end
+
+      def requires_mixed_logic?(context)
+        true
+      end
+
+      def can_be_inlined?
+        false
+      end
+
+      def timer(context)
+        @timer ||= @target.eval(context)
+      end
+
+      def eval(context,options={})
+        case @method
+        when :start
+          "#{timer(context)}=START"
+        when :stop
+          "#{timer(context)}=STOP"
+        when :reset
+          "#{timer(context)}=RESET"
+        when :restart
+          "#{timer(context)}=STOP ;\n#{timer(context)}=RESET ;\n#{timer(context)}=START"
+        else
+          raise "Invalid timer method (#{@method})"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/timer_node.rb

@@ -0,0 +1,21 @@
+module TPPlus
+  module Nodes
+    class TimerNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{comment}"
+      end
+
+      def eval(context, options={})
+        "TIMER[#{@id}#{comment_string}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/units_node.rb

@@ -0,0 +1,20 @@
+module TPPlus
+  module Nodes
+    class UnitsNode
+      def initialize(s)
+        @s = s
+      end
+
+      def eval(context)
+        case @s
+        when "mm/s"
+          "mm/sec"
+        when "%"
+          "%"
+        else
+          raise "Unknown unit: #{@s}"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/use_node.rb

@@ -0,0 +1,21 @@
+module TPPlus
+  module Nodes
+    class UseNode
+      def initialize(type, value)
+        @type = type
+        @value = value
+      end
+
+      def eval(context)
+        case @type
+        when "use_uframe"
+          "UFRAME_NUM=#{@value.eval(context)}"
+        when "use_utool"
+          "UTOOL_NUM=#{@value.eval(context)}"
+        when "use_payload"
+          "PAYLOAD[#{@value.eval(context)}]"
+        end
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/user_alarm_node.rb

@@ -0,0 +1,15 @@
+module TPPlus
+  module Nodes
+    class UserAlarmNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def eval(context, options={})
+        "UALM[#{@id}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/var_method_node.rb

@@ -0,0 +1,23 @@
+module TPPlus
+  module Nodes
+    class VarMethodNode
+      attr_reader :identifier
+      def initialize(identifier, method)
+        @identifier = identifier
+        @method = method
+      end
+
+      def requires_mixed_logic?(context)
+        node(context).requires_mixed_logic?(context)
+      end
+
+      def node(context)
+        context.get_var(@identifier)
+      end
+
+      def eval(context,options={})
+        node(context).eval(context,options.merge(method:@method))
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/var_node.rb

@@ -0,0 +1,39 @@
+module TPPlus
+  module Nodes
+    class VarNode
+      attr_reader :identifier
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def target_node(context)
+        constant? ? context.get_constant(@identifier) : context.get_var(@identifier)
+      end
+
+      def constant?
+        @identifier.upcase == @identifier
+      end
+
+      def requires_mixed_logic?(context)
+        target_node(context).requires_mixed_logic?(context)
+      end
+
+      def with_parens(s, options)
+        return s unless options[:as_condition]
+
+        "(#{s})"
+      end
+
+      def eval(context,options={})
+        return target_node(context).eval(context) if constant?
+
+        s = ""
+        if options[:opposite]
+          s += "!"
+        end
+
+        with_parens(s + target_node(context).eval(context, options), options)
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/vision_register_node.rb

@@ -0,0 +1,21 @@
+module TPPlus
+  module Nodes
+    class VisionRegisterNode
+      attr_accessor :comment
+      def initialize(id)
+        @id = id
+        @comment = ""
+      end
+
+      def comment_string
+        return "" if @comment == ""
+
+        ":#{@comment}"
+      end
+
+      def eval(context,options={})
+        "VR[#{@id}#{comment_string}]"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/wait_for_node.rb

@@ -0,0 +1,54 @@
+module TPPlus
+  module Nodes
+    class WaitForNode
+      def initialize(time, units)
+        @time = time
+        @units = units
+      end
+
+      def units_valid?
+        ["s","ms"].include?(@units)
+      end
+
+      # 2 decimal places and remove leading 0s
+      def time(context)
+        if @time.eval(context).is_a?(String)
+          case @units
+          when "s"
+            @time.eval(context)
+          else
+            raise "Invalid units"
+          end
+        else
+          ("%.2f" % case @units
+          when "s"
+            @time.eval(context)
+          when "ms"
+            @time.eval(context).to_f / 1000
+          end).sub(/^0+/, "") + "(sec)"
+        end
+      end
+
+      def can_be_inlined?
+        false
+      end
+
+      def expression
+        case @units
+        when "s"
+          @time
+        when "ms"
+          e = ExpressionNode.new(@time,"/",DigitNode.new(1000))
+          e.grouped = true
+          e
+        end
+      end
+
+      def eval(context)
+        raise "Invalid units" unless units_valid?
+
+        "WAIT #{time(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/wait_until_node.rb

@@ -0,0 +1,65 @@
+module TPPlus
+  module Nodes
+    class WaitUntilNode
+      def initialize(expression, timeout_options)
+        @expression = expression
+        @timeout_options = timeout_options || {}
+      end
+
+      def timeout(context)
+        return "" if @timeout_options[:label].nil?
+
+        " TIMEOUT,LBL[#{context.labels[@timeout_options[:label].to_sym]}]"
+      end
+
+      def val(context)
+        value_node = @timeout_options[:timeout][0]
+        units = @timeout_options[:timeout][1]
+
+        if value_node.is_a?(VarNode)
+          value = value_node.eval(context)
+
+          case units
+          when "s"
+            value = "#{value}*100"
+          when "ms"
+            value = "#{value}*.1"
+          else
+            raise "invalid units"
+          end
+        else
+          value = value_node.eval(context).to_i
+
+          case units
+          when "s"
+            value = (value * 100).to_i
+          when "ms"
+            value = (value * 0.1).to_i
+          else
+            raise "invalid units"
+          end
+        end
+
+        value
+      end
+
+      def can_be_inlined?
+        false
+      end
+
+      def wait_timeout(context)
+        return "" if @timeout_options[:timeout].nil?
+
+        "$WAITTMOUT=(#{val(context)}) ;\n"
+      end
+
+      def string_value(context)
+        "#{@expression.eval(context, force_parens: true)}"
+      end
+
+      def eval(context)
+        "#{wait_timeout(context)}WAIT #{string_value(context)}#{timeout(context)}"
+      end
+    end
+  end
+end

data/lib/tp_plus/nodes/while_node.rb

@@ -0,0 +1,36 @@
+module TPPlus
+  module Nodes
+    class WhileNode
+      def initialize(condition_node, block)
+        @condition_node = condition_node
+        @block = block.flatten.reject {|n| n.is_a?(TerminatorNode) }
+      end
+
+      def top_label(context)
+        @top_label ||= context.next_label
+      end
+
+      def bottom_label(context)
+        @bottom_label ||= context.next_label
+      end
+
+      def if_statement(context)
+        "IF #{condition(context)},JMP LBL[#{bottom_label(context)}] ;\n"
+      end
+
+
+      def condition(context)
+        @condition_node.eval(context, opposite: true, as_condition: true)
+      end
+
+
+      def block(context)
+        @block.inject("") {|s,n| s << "#{n.eval(context)} ;\n" }
+      end
+
+      def eval(context)
+        "LBL[#{top_label(context)}] ;\n#{if_statement(context)}#{block(context)}JMP LBL[#{top_label(context)}] ;\nLBL[#{bottom_label(context)}]"
+      end
+    end
+  end
+end