rsmp 0.1.19 → 0.1.31

data/lib/rsmp/tlc.rb

@@ -13,7 +13,6 @@ module RSMP
       @cycle_time = cycle_time
       @num_traffic_situations = 1
       @num_inputs = 8
-
       reset
     end
 
@@ -41,6 +40,11 @@ module RSMP
       @input_results = '0'*@num_inputs
     end
 
+    def clock
+      node.clock
+    end
+
+
     def add_signal_group group
       @signal_groups << group
     end
@@ -48,8 +52,12 @@ module RSMP
     def add_detector_logic logic
       @detector_logics << logic
     end
+
     def timer now
-      pos = now.to_i % @cycle_time
+      # TODO
+      # We should use a monotone timer, to avoid jumps
+      # in case the user sets the system time
+      pos = Time.now.to_i % @cycle_time
       if pos != @pos
         @pos = pos
         move pos
@@ -80,7 +88,11 @@ module RSMP
     end
 
     def format_signal_group_status
-      @signal_groups.map { |group| group.state }.join
+      if @yellow_flash
+        'c' * @signal_groups.size
+      else
+        @signal_groups.map { |group| group.state }.join
+      end
     end
 
     def handle_command command_code, arg
@@ -125,18 +137,29 @@ module RSMP
 
     def handle_m0005 arg
       @node.verify_security_code 2, arg['securityCode']
-      @emergency_route = arg['status'] == 'True'
+      @emergency_route = (arg['status'] == 'True')
       @emergency_route_number = arg['emergencyroute'].to_i
+
+      if @emergency_route
+        log "Switching to emergency route #{@emergency_route_number}", level: :info
+      else
+        log "Switching off emergency route", level: :info
+      end
     end
 
     def handle_m0006 arg
       @node.verify_security_code 2, arg['securityCode']
       input = arg['input'].to_i
       idx = input - 1
-      return unless idx>=0 && input<@num_inputs
+      return unless idx>=0 && input<@num_inputs # TODO should NotAck
       @input_activations[idx] = (arg['status']=='True' ? '1' : '0')
       result = @input_activations[idx]=='1' || @inputs[idx]=='1'
       @input_results[idx] = (result ? '1' : '0')
+      if @input_activations[idx]
+        log "Activate input #{idx}", level: :info
+      else
+        log "Deactivate input #{idx}", level: :info
+      end
     end
 
     def handle_m0007 arg
@@ -191,6 +214,17 @@ module RSMP
 
     def handle_m0104 arg
       @node.verify_security_code 1, arg['securityCode']
+      time = Time.new(
+        arg['year'],
+        arg['month'],
+        arg['day'],
+        arg['hour'],
+        arg['minute'],
+        arg['second'],
+        'UTC'
+      )
+      @node.clock.set time
+      log "Clock set to #{time}, (adjustment is #{@node.clock.adjustment}s)", level: :info
     end
 
     def set_input i, value
@@ -203,8 +237,13 @@ module RSMP
     end
 
     def switch_plan plan
-      log "Switching to plan #{plan}", level: :info
-      @plan = plan.to_i
+      plan_nr = plan.to_i
+      if plan_nr == 0
+        log "Switching to plan selection by time table", level: :info
+      else
+        log "Switching to plan #{plan_nr}", level: :info
+      end
+      @plan = plan_nr
     end
 
     def switch_mode mode
@@ -502,35 +541,37 @@ module RSMP
     end
 
     def handle_s0096 status_code, status_name=nil
+      now = clock.now
       case status_name
       when 'year'
-        RSMP::Tlc.make_status RSMP.now_object.year.to_s.rjust(4, "0")
+        RSMP::Tlc.make_status now.year.to_s.rjust(4, "0")
       when 'month'
-        RSMP::Tlc.make_status RSMP.now_object.month.to_s.rjust(2, "0")
+        RSMP::Tlc.make_status now.month.to_s.rjust(2, "0")
       when 'day'
-        RSMP::Tlc.make_status RSMP.now_object.day.to_s.rjust(2, "0")
+        RSMP::Tlc.make_status now.day.to_s.rjust(2, "0")
       when 'hour'
-        RSMP::Tlc.make_status RSMP.now_object.hour.to_s.rjust(2, "0")
+        RSMP::Tlc.make_status now.hour.to_s.rjust(2, "0")
       when 'minute'
-        RSMP::Tlc.make_status RSMP.now_object.min.to_s.rjust(2, "0")
+        RSMP::Tlc.make_status now.min.to_s.rjust(2, "0")
       when 'second'
-        RSMP::Tlc.make_status RSMP.now_object.sec.to_s.rjust(2, "0")
+        RSMP::Tlc.make_status now.sec.to_s.rjust(2, "0")
       end
     end
 
     def handle_s0097 status_code, status_name=nil
       case status_name
-      when 'version'
-        RSMP::Tlc.make_status '1'
-      when 'hash'
+      when 'checksum'
         RSMP::Tlc.make_status '1'
+      when 'timestamp'
+        now = @node.clock.to_s
+        RSMP::Tlc.make_status now
       end
     end
 
     def handle_s0205 status_code, status_name=nil
       case status_name
       when 'start'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status clock.to_s
       when 'vehicles'
         RSMP::Tlc.make_status 0
       end
@@ -539,7 +580,7 @@ module RSMP
     def handle_s0206 status_code, status_name=nil
       case status_name
       when 'start'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status clock.to_s
       when 'speed'
         RSMP::Tlc.make_status 0
       end
@@ -548,7 +589,7 @@ module RSMP
     def handle_s0207 status_code, status_name=nil
       case status_name
       when 'start'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status clock.to_s
       when 'occupancy'
         RSMP::Tlc.make_status 0
       end
@@ -557,7 +598,7 @@ module RSMP
     def handle_s0208 status_code, status_name=nil
       case status_name
       when 'start'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status clock.to_s
       when 'P'
         RSMP::Tlc.make_status 0
       when 'PS'
@@ -637,21 +678,22 @@ module RSMP
     end
 
     def handle_s0025 status_code, status_name=nil
+      now = @node.clock.to_s
       case status_name
       when 'minToGEstimate'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status now
       when 'maxToGEstimate'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status now
       when 'likelyToGEstimate'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status now
       when 'ToGConfidence'
         RSMP::Tlc.make_status 0
       when 'minToREstimate'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status now
       when 'maxToREstimate'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status now
       when 'likelyToREstimate'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status now
       when 'ToRConfidence'
         RSMP::Tlc.make_status 0
       end
@@ -679,7 +721,7 @@ module RSMP
     def handle_s0201 status_code, status_name=nil
       case status_name
       when 'starttime'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status @node.clock.to_s
       when 'vehicles'
         RSMP::Tlc.make_status 0
       end
@@ -688,7 +730,7 @@ module RSMP
     def handle_s0202 status_code, status_name=nil
       case status_name
       when 'starttime'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status @node.clock.to_s
       when 'speed'
         RSMP::Tlc.make_status 0
       end
@@ -697,7 +739,7 @@ module RSMP
     def handle_s0203 status_code, status_name=nil
       case status_name
       when 'starttime'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status @node.clock.to_s
       when 'occupancy'
         RSMP::Tlc.make_status 0
       end
@@ -706,7 +748,7 @@ module RSMP
     def handle_s0204 status_code, status_name=nil
       case status_name
       when 'starttime'
-        RSMP::Tlc.make_status RSMP.now_string
+        RSMP::Tlc.make_status @node.clock.to_s
       when 'P'
         RSMP::Tlc.make_status 0
       when 'PS'
@@ -751,6 +793,7 @@ module RSMP
   end
 
   class Tlc < Site
+    attr_accessor :main
     def initialize options={}
       super options
       @sxl = 'traffic_light_controller'
@@ -790,22 +833,21 @@ module RSMP
         next_time = Time.now.to_f
         loop do
           begin
-            now = RSMP.now_object
-            timer(now)
+            timer(@clock.now)
           rescue EOFError => e
-            log "TLC timer: Connection closed: #{e}", level: :warning
+            log "Connection closed: #{e}", level: :warning
           rescue IOError => e
-            log "TLC timer: IOError", level: :warning
+            log "IOError", level: :warning
           rescue Errno::ECONNRESET
-            log "TLC timer: Connection reset by peer", level: :warning
+            log "Connection reset by peer", level: :warning
           rescue Errno::EPIPE => e
-            log "TLC timer: Broken pipe", level: :warning
+            log "Broken pipe", level: :warning
           rescue StandardError => e
-            log "TLC timer: #{e}", level: :debug
+            notify_error e, level: :internal
           ensure
             # adjust sleep duration to avoid drift. so wake up always happens on the
             # same fractional second.
-            # note that Time.now is not monotonic. If the clock si changed,
+            # note that Time.now is not monotonic. If the clock is changed,
             # either manaully or via NTP, the sleep interval might jump.
             # an alternative is to use ::Process.clock_gettime(::Process::CLOCK_MONOTONIC),
             # to get the current time. this ensures a constant interval, but

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = "0.1.19"
+  VERSION = "0.1.31"
 end

data/lib/rsmp/wait.rb

@@ -1,163 +1,16 @@
-# Helper for waiting for an Async condition using a block
-
 module RSMP
   module Wait
-
+    # wait for an async condition to signal, then yield to block
+    # if block returns true we're done. otherwise, wait again
     def wait_for condition, timeout, &block
-      raise RuntimeError.new("Can't wait for state because task is stopped") unless @task.running? 
+      raise RuntimeError.new("Can't wait for condition because task is not running") unless @task.running?
       @task.with_timeout(timeout) do
-        while task.running? do
+        while @task.running? do
           value = condition.wait
           result = yield value 
           return result if result   # return result of check, if not nil
         end
       end
     end   
-
-    def capture_status_updates_or_responses task, type, options, m_id
-      task.annotate "wait for status update/response"
-      want = convert_status_list options[:status_list]
-      result = {}
-      # wait for a status update
-      item = @archive.capture(task,options.merge({
-        type: [type,'MessageNotAck'],
-        num: 1
-      })) do |item|
-        message = item[:message]
-        if message.is_a?(MessageNotAck) && message.attribute('oMId') == m_id
-          # set result to an exception, but don't raise it.
-          # this will be returned by the task and stored as the task result
-          # when the parent task call wait() on the task, the exception
-          # will be raised in the parent task, and caught by rspec.
-          # rspec will then show the error and record the test as failed
-          m_id_short = RSMP::Message.shorten_m_id m_id, 8
-          result = RSMP::MessageRejected.new "Status request #{m_id_short} was rejected: #{message.attribute('rea')}"
-          next true   # done, no more messages wanted
-        end
-        found = []
-        # look through querues
-        want.each_with_index do |query,i|
-          # look through status items in message
-          item[:message].attributes['sS'].each do |input|
-            ok = status_match? query, input
-            if ok
-              result[query] = input
-              found << i   # record which queries where matched succesfully
-            end
-          end
-        end
-        # remove queries that where matched
-        found.sort.reverse.each do |i|
-          want.delete_at i
-        end
-        want.empty? # any queries left to match?
-      end
-      result
-    rescue Async::TimeoutError
-      type_str = {'StatusUpdate'=>'update', 'StatusResponse'=>'response'}[type]
-      raise RSMP::TimeoutError.new "Did not received status #{type_str} in reply to #{m_id} within #{options[:timeout]}s"
-    end
-
-    def wait_for_status_updates_or_responses parent_task, type, options={}, &block
-      raise ArgumentError.new("component argument is missing") unless options[:component]
-      raise ArgumentError.new("status_list argument is missing") unless options[:status_list]
-      m_id = RSMP::Message.make_m_id    # make message id so we can start waiting for it
-
-      # wait for command responses in an async task
-      task = parent_task.async do |task|
-        capture_status_updates_or_responses task, type, options, m_id
-      end
-
-       # call block, it should send command request using the given m_id
-      yield m_id
-
-      # wait for the response and return it, raise exception if NotAck received, it it timed out
-      task.wait
-    end
-
-    def wait_for_status_updates parent_task, options={}, &block
-      wait_for_status_updates_or_responses parent_task, 'StatusUpdate', options, &block
-    end
-
-    def wait_for_status_responses parent_task, options={}, &block
-      wait_for_status_updates_or_responses parent_task, 'StatusResponse', options, &block
-    end
-
-    def process_command_response message
-      log "Received #{message.type}", message: message, level: :log
-      acknowledge message
-    end
-
-    def command_match? query, item
-      return false if query[:sCI] && query[:sCI] != item['sCI']
-      return false if query[:n] && query[:n] != item['n']
-      if query[:s].is_a? Regexp
-        return false if query[:v] && item['v'] !~ query[:v]
-      else
-        return false if query[:v] && item['v'] != query[:v]
-      end
-      true
-    end
-
-    def capture_command_responses parent_task, type, options, m_id
-      task.annotate "wait for command response"
-      want = options[:command_list].clone
-      result = {}
-      item = @archive.capture(parent_task,options.merge({
-        type: [type,'MessageNotAck'],
-        num: 1
-      })) do |item|
-        message = item[:message]
-        if message.is_a?(MessageNotAck) && message.attribute('oMId') == m_id
-           # and message.attribute('oMId')==m_id
-          # set result to an exception, but don't raise it.
-          # this will be returned by the task and stored as the task result
-          # when the parent task call wait() on the task, the exception
-          # will be raised in the parent task, and caught by rspec.
-          # rspec will then show the error and record the test as failed
-          m_id_short = RSMP::Message.shorten_m_id m_id, 8
-          result = RSMP::MessageRejected.new "Command request #{m_id_short} was rejected: #{message.attribute('rea')}"
-          next true   # done, no more messages wanted
-        end
-
-        found = []
-        # look through querues
-        want.each_with_index do |query,i|
-          # look through items in message
-          item[:message].attributes['rvs'].each do |input|
-            ok = command_match? query, input
-            if ok
-              result[query] = input
-              found << i   # record which queries where matched succesfully
-            end
-          end
-        end
-        # remove queries that where matched
-        found.sort.reverse.each do |i|
-          want.delete_at i
-        end
-        want.empty? # any queries left to match?
-      end
-      result
-    rescue Async::TimeoutError
-      raise RSMP::TimeoutError.new "Did not receive command response to #{m_id} within #{options[:timeout]}s"
-    end
-
-    def wait_for_command_responses parent_task, options={}, &block
-      raise ArgumentError.new("component argument is missing") unless options[:component]
-      raise ArgumentError.new("command_list argument is missing") unless options[:command_list]
-      m_id = RSMP::Message.make_m_id    # make message id so we can start waiting for it
-
-      # wait for command responses in an async task
-      task = parent_task.async do |task|
-        capture_command_responses task, 'CommandResponse', options, m_id
-      end
-
-       # call block, it should send command request using the given m_id
-      yield m_id
-
-      # wait for the response and return it, raise exception if NotAck received, it it timed out
-      task.wait
-    end
   end
 end