rsmp 0.1.10 → 0.1.19

data/lib/rsmp/supervisor.rb

@@ -98,7 +98,7 @@ module RSMP
       true
     end
 
-    def build_connector settings
+    def build_proxy settings
       SiteProxy.new settings
     end
 
@@ -117,7 +117,7 @@ module RSMP
           level: :info,
           timestamp: RSMP.now_object
 
-      proxy = build_connector({
+      proxy = build_proxy({
         supervisor: self,
         task: @task,
         settings: @supervisor_settings[:sites],
@@ -129,6 +129,7 @@ module RSMP
       @proxies.push proxy
       
       proxy.run     # will run until the site disconnects
+    ensure
       @proxies.delete proxy
       site_ids_changed
 
@@ -159,7 +160,7 @@ module RSMP
 
     def find_site site_id
       @proxies.each do |site|
-        return site if site.site_id == site_id
+        return site if site_id == :any || site.site_id == site_id
       end
       nil
     end
@@ -167,13 +168,13 @@ module RSMP
     def wait_for_site site_id, timeout
       site = find_site site_id
       return site if site
-      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { find_site site_id }
+      wait_for(@site_id_condition,timeout) { find_site site_id }
     rescue Async::TimeoutError
       nil
     end
 
     def wait_for_site_disconnect site_id, timeout
-      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { true unless find_site site_id }
+      wait_for(@site_id_condition,timeout) { true unless find_site site_id }
     rescue Async::TimeoutError
       false
     end

data/lib/rsmp/supervisor_proxy.rb

@@ -28,6 +28,7 @@ module RSMP
       super
       connect
       @logger.unmute @ip, @port
+      log "Connected to superviser at #{@ip}:#{@port}", level: :info
       start_reader
       send_version @site_settings['site_id'], @site_settings["rsmp_versions"]
     rescue Errno::ECONNREFUSED
@@ -38,6 +39,12 @@ module RSMP
       end
     end
 
+    def stop
+      log "Closing connection to supervisor", level: :info
+      super
+      @last_status_sent = nil
+    end
+
     def connect
       return if @socket
       @endpoint = Async::IO::Endpoint.tcp(@ip, @port)
@@ -72,6 +79,13 @@ module RSMP
         else
           super message
       end
+    rescue UnknownComponent, UnknownCommand, UnknownStatus,
+           MessageRejected, MissingAttribute => e
+      dont_acknowledge message, '', e.to_s
+    end
+
+    def process_deferred
+      site.process_deferred
     end
 
     def acknowledged_first_ingoing message
@@ -112,7 +126,7 @@ module RSMP
       message = AggregatedStatus.new({
         "aSTS" => RSMP.now_string,
         "cId" =>  component.c_id,
-        "fP" => nil,
+        "fP" => 'NormalControl',
         "fS" => nil,
         "se" => component.aggregated_status_bools
       })
@@ -135,22 +149,35 @@ module RSMP
       acknowledge message
     end
 
+    # reorganize rmsp command request arg attribute:
+    # [{"cCI":"M0002","cO":"setPlan","n":"status","v":"True"},{"cCI":"M0002","cO":"setPlan","n":"securityCode","v":"5678"},{"cCI":"M0002","cO":"setPlan","n":"timeplan","v":"3"}]
+    # into the simpler, but equivalent:
+    # {"M0002"=>{"status"=>"True", "securityCode"=>"5678", "timeplan"=>"3"}}
+    def simplify_command_requests arg
+      sorted = {}
+      arg.each do |item|
+        sorted[item['cCI']] ||= {}
+        sorted[item['cCI']][item['n']] = item['v']
+      end
+      sorted
+    end
+
     def process_command_request message
       log "Received #{message.type}", message: message, level: :log
-      rvs = []
-      message.attributes["arg"].each do |arg|
-        unless arg['cCI'] && arg['n'] && arg['v']
-          dont_acknowledge message, '', 'bad arguments'
-          return
-        end 
-        rvs << { "cCI" => arg["cCI"],
-                 "n" => arg["n"],
-                 "v" => arg["v"],
-                 "age" => "recent" }
+      component_id = message.attributes["cId"]
+      component = @site.find_component component_id
+      commands = simplify_command_requests message.attributes["arg"]
+      commands.each_pair do |command_code,arg|
+        component.handle_command command_code,arg
       end
 
+      rvs = message.attributes["arg"].map do |item|
+        item = item.dup.merge('age'=>'recent')
+        item.delete 'cO'
+        item
+      end
       response = CommandResponse.new({
-        "cId"=>message.attributes["cId"],
+        "cId"=>component_id,
         "cTS"=>RSMP.now_string,
         "rvs"=>rvs
       })
@@ -158,25 +185,22 @@ module RSMP
       send_message response
     end
 
-    def process_status_request message
+    def process_status_request message, options={}
       component_id = message.attributes["cId"]
       component = @site.find_component component_id
-
       log "Received #{message.type}", message: message, level: :log
-      sS = message.attributes["sS"].clone.map do |request|
-        request["s"] = rand(100).to_s
-        request["q"] = "recent"
-        request
+      sS = message.attributes["sS"].map do |arg|
+        value, quality =  component.get_status arg['sCI'], arg['n']
+        { "s" => value.to_s, "q" => quality.to_s }.merge arg
       end
       response = StatusResponse.new({
         "cId"=>component_id,
         "sTs"=>RSMP.now_string,
-        "sS"=>sS
+        "sS"=>sS,
+        "mId" => options[:m_id]
       })
       acknowledge message
       send_message response
-    rescue UnknownComponent => e
-      dont_acknowledge message, '', e.to_s
     end
 
     def process_status_subcribe message
@@ -198,10 +222,11 @@ module RSMP
       update_list[component] ||= {} 
 
       subs = @status_subscriptions[component]
+      now = RSMP::now_object
 
       message.attributes["sS"].each do |arg|
         sCI = arg["sCI"]
-        subcription = {interval: arg["uRt"].to_i, last_sent_at: nil}
+        subcription = {interval: arg["uRt"].to_i, last_sent_at: now}
         subs[sCI] ||= {}
         subs[sCI][arg["n"]] = subcription
 
@@ -235,18 +260,40 @@ module RSMP
       status_update_timer now if ready?
     end
 
+    def fetch_last_sent_status component, code, name
+      if @last_status_sent && @last_status_sent[component] && @last_status_sent[component][code]
+        @last_status_sent[component][code][name]
+      else
+        nil
+      end
+    end
+
+    def store_last_sent_status component, code, name, value
+      @last_status_sent ||= {}
+      @last_status_sent[component] ||= {}
+      @last_status_sent[component][code] ||= {}
+      @last_status_sent[component][code][name] = value
+    end
+
     def status_update_timer now
       update_list = {}
       # go through subscriptons and build a similarly organized list,
       # that only contains what should be send
 
       @status_subscriptions.each_pair do |component,by_code|
+        component_object = @site.find_component component
         by_code.each_pair do |code,by_name|
           by_name.each_pair do |name,subscription|
+            current = nil
             if subscription[:interval] == 0 
               # send as soon as the data changes
-              if rand(100) >= 90
+              if component_object
+                current, age = *(component_object.get_status code, name)
+              end
+              last_sent = fetch_last_sent_status component, code, name
+              if current != last_sent
                 should_send = true
+                store_last_sent_status component, code, name, current
               end
             else
               # send at regular intervals
@@ -257,8 +304,8 @@ module RSMP
             if should_send
               subscription[:last_sent_at] = now
               update_list[component] ||= {}
-              update_list[component][code] ||= []
-              update_list[component][code] << name
+              update_list[component][code] ||= {}
+              update_list[component][code][name] = current
            end
           end
         end
@@ -270,18 +317,24 @@ module RSMP
 
     def send_status_updates update_list
       now = RSMP.now_string
-      update_list.each_pair do |component,by_code|
+      update_list.each_pair do |component_id,by_code|
+        component = @site.find_component component_id
         sS = []
         by_code.each_pair do |code,names|
-          names.each do |name|
+          names.map do |status_name,value|
+            if value
+              quality = 'recent'
+            else
+              value,quality = component.get_status code, status_name
+            end
             sS << { "sCI" => code,
-                     "n" => name,
-                     "s" => rand(100).to_s,
-                     "q" => "recent" }
+                     "n" => status_name,
+                     "s" => value.to_s,
+                     "q" => quality }
           end
         end
         update = StatusUpdate.new({
-          "cId"=>component,
+          "cId"=>component_id,
           "sTs"=>now,
           "sS"=>sS
         })

data/lib/rsmp/tlc.rb

@@ -0,0 +1,869 @@
+# Simulates a Traffic Light Controller
+
+module RSMP
+
+  class TrafficController < Component
+    attr_reader :pos, :cycle_time
+
+    def initialize node:, id:, cycle_time:
+      super node: node, id: id, grouped: true
+      @signal_groups = []
+      @detector_logics = []
+      @plans = []
+      @cycle_time = cycle_time
+      @num_traffic_situations = 1
+      @num_inputs = 8
+
+      reset
+    end
+
+    def reset
+      @pos = 0
+      @plan = 0
+      @dark_mode = false
+      @yellow_flash = false
+      @booting = false
+      @control_mode = 'control'
+      @police_key = 0
+      @intersection = 0
+      @is_starting = false
+      @emergency_route = false
+      @emergency_route_number = 0
+      @traffic_situation = 0
+      @manual_control = false
+      @fixed_time_control = false
+      @isolated_control = false
+      @yellow_flash = false
+      @all_red = false
+
+      @inputs = '0'*@num_inputs
+      @input_activations = '0'*@num_inputs
+      @input_results = '0'*@num_inputs
+    end
+
+    def add_signal_group group
+      @signal_groups << group
+    end
+
+    def add_detector_logic logic
+      @detector_logics << logic
+    end
+    def timer now
+      pos = now.to_i % @cycle_time
+      if pos != @pos
+        @pos = pos
+        move pos
+      end
+    end
+
+    def move pos
+      @signal_groups.each do |group|
+        group.move pos
+      end
+      if pos == 0
+        aggrated_status_changed
+      end
+    end
+
+    def output_states
+      str = @signal_groups.map do |group|
+        s = "#{group.c_id}:#{group.state}"
+        if group.state =~ /^[1-9]$/
+          s.colorize(:green)
+      elsif group.state =~ /^[NOP]$/
+          s.colorize(:yellow)
+        else
+          s.colorize(:red)
+        end
+      end.join ' '
+      print "\t#{pos.to_s.ljust(3)} #{str}\r"
+    end
+
+    def format_signal_group_status
+      @signal_groups.map { |group| group.state }.join
+    end
+
+    def handle_command command_code, arg
+      case command_code
+      when 'M0001', 'M0002', 'M0003', 'M0004', 'M0005', 'M0006', 'M0007',
+           'M0012', 'M0013', 'M0014', 'M0015', 'M0016', 'M0017', 'M0018',
+           'M0019', 'M0020', 'M0021', 'M0022',
+           'M0103', 'M0104'
+
+        return send("handle_#{command_code.downcase}", arg)
+      else
+        raise UnknownCommand.new "Unknown command #{command_code}"
+      end
+    end
+
+    def handle_m0001 arg
+      @node.verify_security_code 2, arg['securityCode']
+      switch_mode arg['status']
+    end
+
+    def handle_m0002 arg
+      @node.verify_security_code 2, arg['securityCode']
+      if RSMP::Tlc.from_rsmp_bool(arg['status'])
+        switch_plan arg['timeplan']
+      else
+        switch_plan 0   # TODO use clock/calender
+      end
+    end
+
+    def handle_m0003 arg
+      @node.verify_security_code 2, arg['securityCode']
+      @traffic_situation = arg['traficsituation'].to_i
+    end
+
+    def handle_m0004 arg
+      @node.verify_security_code 2, arg['securityCode']
+      # don't restart immeediately, since we need to first send command response
+      # instead, defer an action, which will be handled by the TLC site
+      log "Sheduling restart of TLC", level: :info
+      @node.defer :restart
+    end
+
+    def handle_m0005 arg
+      @node.verify_security_code 2, arg['securityCode']
+      @emergency_route = arg['status'] == 'True'
+      @emergency_route_number = arg['emergencyroute'].to_i
+    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
+      @input_activations[idx] = (arg['status']=='True' ? '1' : '0')
+      result = @input_activations[idx]=='1' || @inputs[idx]=='1'
+      @input_results[idx] = (result ? '1' : '0')
+    end
+
+    def handle_m0007 arg
+      @node.verify_security_code 2, arg['securityCode']
+      set_fixed_time_control arg['status']
+    end
+
+    def handle_m0012 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0013 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0014 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0015 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0016 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0017 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0018 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0019 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0020 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0021 arg
+      @node.verify_security_code 2, arg['securityCode']
+    end
+
+    def handle_m0103 arg
+      level = {'Level1'=>1,'Level2'=>2}[arg['status']]
+      @node.change_security_code level, arg['oldSecurityCode'], arg['newSecurityCode']
+    end
+
+    def handle_m0104 arg
+      @node.verify_security_code 1, arg['securityCode']
+    end
+
+    def set_input i, value
+      return unless i>=0 && i<@num_inputs
+      @inputs[i] = (arg['value'] ? '1' : '0')
+    end
+    
+    def set_fixed_time_control status
+      @fixed_time_control = status
+    end
+
+    def switch_plan plan
+      log "Switching to plan #{plan}", level: :info
+      @plan = plan.to_i
+    end
+
+    def switch_mode mode
+      log "Switching to mode #{mode}", level: :info
+      case mode
+      when 'NormalControl'
+        @yellow_flash = false
+        @dark_mode = false
+      when 'YellowFlash'
+        @yellow_flash = true
+        @dark_mode = false
+      when 'Dark'
+        @yellow_flash = false
+        @dark_mode = true
+      end
+      mode
+    end
+
+    def get_status code, name=nil
+      case code
+      when 'S0001', 'S0002', 'S0003', 'S0004', 'S0005', 'S0006', 'S0007',
+           'S0008', 'S0009', 'S0010', 'S0011', 'S0012', 'S0013', 'S0014',
+           'S0015', 'S0016', 'S0017', 'S0018', 'S0019', 'S0020', 'S0021',
+           'S0022', 'S0023', 'S0024', 'S0026', 'S0027', 'S0028',
+           'S0029', 'S0030', 'S0031',
+           'S0091', 'S0092', 'S0095', 'S0096', 'S0097',
+           'S0205', 'S0206', 'S0207', 'S0208'
+        return send("handle_#{code.downcase}", code, name)
+      else
+        raise InvalidMessage.new "unknown status code #{code}"
+      end
+    end
+
+    def handle_s0001 status_code, status_name=nil
+      case status_name
+      when 'signalgroupstatus'
+        RSMP::Tlc.make_status format_signal_group_status
+      when 'cyclecounter'
+        RSMP::Tlc.make_status @pos.to_s
+      when 'basecyclecounter'
+        RSMP::Tlc.make_status @pos.to_s
+      when 'stage'
+        RSMP::Tlc.make_status 0.to_s
+      end
+    end
+
+    def handle_s0002 status_code, status_name=nil
+      case status_name
+      when 'detectorlogicstatus'
+        RSMP::Tlc.make_status @detector_logics.map { |dl| dl.forced ? '1' : '0' }.join
+      end
+    end
+
+    def handle_s0003 status_code, status_name=nil
+      case status_name
+      when 'inputstatus'
+        RSMP::Tlc.make_status @input_results
+      when 'extendedinputstatus'
+        RSMP::Tlc.make_status 0.to_s
+      end
+    end
+
+    def handle_s0004 status_code, status_name=nil
+      case status_name
+      when 'outputstatus'
+        RSMP::Tlc.make_status 0
+      when 'extendedoutputstatus'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0005 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status @is_starting
+      end
+    end
+
+    def handle_s0006 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status @emergency_route
+      when 'emergencystage'
+        RSMP::Tlc.make_status @emergency_route_number
+      end
+    end
+
+    def handle_s0007 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status !@dark_mode
+      end
+    end
+
+    def handle_s0008 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status @manual_control
+      end
+    end
+
+    def handle_s0009 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status @fixed_time_control
+      end
+    end
+
+    def handle_s0010 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status @isolated_control
+      end
+    end
+
+    def handle_s0011 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status @yellow_flash
+      end
+    end
+
+    def handle_s0012 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status @all_red
+      end
+    end
+
+    def handle_s0013 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'status'
+        RSMP::Tlc.make_status @police_key
+      end
+    end
+
+    def handle_s0014 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status @plan
+      end
+    end
+
+    def handle_s0015 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status @traffic_situation
+      end
+    end
+
+    def handle_s0016 status_code, status_name=nil
+      case status_name
+      when 'number'
+        RSMP::Tlc.make_status @detector_logics.size
+      end
+    end
+
+    def handle_s0017 status_code, status_name=nil
+      case status_name
+      when 'number'
+        RSMP::Tlc.make_status @signal_groups.size
+      end
+    end
+
+    def handle_s0018 status_code, status_name=nil
+      case status_name
+      when 'number'
+        RSMP::Tlc.make_status @plans.size
+      end
+    end
+
+    def handle_s0019 status_code, status_name=nil
+      case status_name
+      when 'number'
+        RSMP::Tlc.make_status @num_traffic_situations
+      end
+    end
+
+    def handle_s0020 status_code, status_name=nil
+      case status_name
+      when 'intersection'
+        RSMP::Tlc.make_status @intersection
+      when 'controlmode'
+        RSMP::Tlc.make_status @control_mode
+      end
+    end
+
+    def handle_s0021 status_code, status_name=nil
+      case status_name
+      when 'detectorlogics'
+        RSMP::Tlc.make_status @detector_logics.map { |logic| logic.forced=='True' ? '1' : '0'}.join
+      end
+    end
+
+    def handle_s0022 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status '1'
+      end
+    end
+
+    def handle_s0023 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status '1-1-0'
+      end
+    end
+
+    def handle_s0024 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status '1-0'
+      end
+    end
+
+    def handle_s0026 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status '0-00'
+      end
+    end
+
+    def handle_s0027 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status '00-00-00-00'
+      end
+    end
+
+    def handle_s0028 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status '00-00'
+      end
+    end
+
+    def handle_s0029 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status ''
+      end
+    end
+
+    def handle_s0030 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status ''
+      end
+    end
+
+    def handle_s0031 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status ''
+      end
+    end
+
+    def handle_s0091 status_code, status_name=nil
+      case status_name
+      when 'user'
+        RSMP::Tlc.make_status 'nobody'
+      when 'status'
+        RSMP::Tlc.make_status 'logout'
+      end
+    end
+
+    def handle_s0092 status_code, status_name=nil
+      case status_name
+      when 'user'
+        RSMP::Tlc.make_status 'nobody'
+      when 'status'
+        RSMP::Tlc.make_status 'logout'
+      end
+    end
+
+    def handle_s0095 status_code, status_name=nil
+      case status_name
+      when 'status'
+        RSMP::Tlc.make_status RSMP::VERSION
+      end
+    end
+
+    def handle_s0096 status_code, status_name=nil
+      case status_name
+      when 'year'
+        RSMP::Tlc.make_status RSMP.now_object.year.to_s.rjust(4, "0")
+      when 'month'
+        RSMP::Tlc.make_status RSMP.now_object.month.to_s.rjust(2, "0")
+      when 'day'
+        RSMP::Tlc.make_status RSMP.now_object.day.to_s.rjust(2, "0")
+      when 'hour'
+        RSMP::Tlc.make_status RSMP.now_object.hour.to_s.rjust(2, "0")
+      when 'minute'
+        RSMP::Tlc.make_status RSMP.now_object.min.to_s.rjust(2, "0")
+      when 'second'
+        RSMP::Tlc.make_status RSMP.now_object.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'
+        RSMP::Tlc.make_status '1'
+      end
+    end
+
+    def handle_s0205 status_code, status_name=nil
+      case status_name
+      when 'start'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'vehicles'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0206 status_code, status_name=nil
+      case status_name
+      when 'start'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'speed'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0207 status_code, status_name=nil
+      case status_name
+      when 'start'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'occupancy'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0208 status_code, status_name=nil
+      case status_name
+      when 'start'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'P'
+        RSMP::Tlc.make_status 0
+      when 'PS'
+        RSMP::Tlc.make_status 0
+      when 'L'
+        RSMP::Tlc.make_status 0
+      when 'LS'
+        RSMP::Tlc.make_status 0
+      when 'B'
+        RSMP::Tlc.make_status 0
+      when 'SP'
+        RSMP::Tlc.make_status 0
+      when 'MC'
+        RSMP::Tlc.make_status 0
+      when 'C'
+        RSMP::Tlc.make_status 0
+      when 'F'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+  end
+
+  class SignalGroup < Component
+    attr_reader :plan, :state
+
+    def initialize node:, id:, plan:
+      super node: node, id: id, grouped: false
+      @plan = plan
+      move 0
+    end
+
+    def get_state pos
+      if pos > @plan.length
+        '.'
+      else
+        @plan[pos]
+      end
+    end
+
+    def move pos
+      @state = get_state pos
+    end
+
+    def handle_command command_code, arg
+      case command_code
+      when 'M0010', 'M0011'
+        return send("handle_#{command_code.downcase}", arg)
+      else
+        raise UnknownCommand.new "Unknown command #{command_code}"
+      end
+    end
+
+    # Start of signal group. Orders a signal group to green
+    def handle_m0010 arg
+      @node.verify_security_code 2, arg['securityCode']
+      if RSMP::Tlc.from_rsmp_bool arg['status']
+        log "Start signal group #{c_id}, go to green", level: :info
+      end
+    end
+
+    # Stop of signal group. Orders a signal group to red
+    def handle_m0011 arg
+      @node.verify_security_code 2, arg['securityCode']
+      if RSMP::Tlc.from_rsmp_bool arg['status']
+        log "Stop signal group #{c_id}, go to red", level: :info
+      end
+    end
+
+    def get_status code, name=nil
+      case code
+      when 'S0025'
+        return send("handle_#{code.downcase}", code, name)
+      else
+        raise InvalidMessage.new "unknown status code #{code}"
+      end
+    end
+
+    def handle_s0025 status_code, status_name=nil
+      case status_name
+      when 'minToGEstimate'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'maxToGEstimate'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'likelyToGEstimate'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'ToGConfidence'
+        RSMP::Tlc.make_status 0
+      when 'minToREstimate'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'maxToREstimate'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'likelyToREstimate'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'ToRConfidence'
+        RSMP::Tlc.make_status 0
+      end
+    end
+  end
+
+  class DetectorLogic < Component
+    attr_reader :status, :forced, :value
+
+    def initialize node:, id:
+      super node: node, id: id, grouped: false
+      @forced = 0
+      @value = 0
+    end
+
+    def get_status code, name=nil
+      case code
+      when 'S0201', 'S0202', 'S0203', 'S0204'
+        return send("handle_#{code.downcase}", code, name)
+      else
+        raise InvalidMessage.new "unknown status code #{code}"
+      end
+    end
+
+    def handle_s0201 status_code, status_name=nil
+      case status_name
+      when 'starttime'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'vehicles'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0202 status_code, status_name=nil
+      case status_name
+      when 'starttime'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'speed'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0203 status_code, status_name=nil
+      case status_name
+      when 'starttime'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'occupancy'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_s0204 status_code, status_name=nil
+      case status_name
+      when 'starttime'
+        RSMP::Tlc.make_status RSMP.now_string
+      when 'P'
+        RSMP::Tlc.make_status 0
+      when 'PS'
+        RSMP::Tlc.make_status 0
+      when 'L'
+        RSMP::Tlc.make_status 0
+      when 'LS'
+        RSMP::Tlc.make_status 0
+      when 'B'
+        RSMP::Tlc.make_status 0
+      when 'SP'
+        RSMP::Tlc.make_status 0
+      when 'MC'
+        RSMP::Tlc.make_status 0
+      when 'C'
+        RSMP::Tlc.make_status 0
+      when 'F'
+        RSMP::Tlc.make_status 0
+      end
+    end
+
+    def handle_command command_code, arg
+      case command_code
+      when 'M0008'
+        handle_m0008 arg
+      else
+        raise UnknownCommand.new "Unknown command #{command_code}"
+      end
+    end
+
+    def handle_m0008 arg
+      @node.verify_security_code 2, arg['securityCode']
+      force_detector_logic arg['status']=='True', arg['value']='True'
+      arg
+    end
+
+    def force_detector_logic status, value
+      @forced = status
+      @value = value
+    end
+
+  end
+
+  class Tlc < Site
+    def initialize options={}
+      super options
+      @sxl = 'traffic_light_controller'
+      @security_codes = options[:site_settings]['security_codes']
+      @interval = options[:site_settings]['interval'] || 1
+      unless @main
+        raise ConfigurationError.new "TLC must have a main component"
+      end
+    end
+
+    def build_component id:, type:, settings:{}
+      component = case type
+      when 'main'
+        @main = TrafficController.new node: self, id: id, cycle_time: settings['cycle_time']
+      when 'signal_group'
+        group = SignalGroup.new node: self, id: id, plan: settings['plan']
+        @main.add_signal_group group
+        group
+      when 'detector_logic'
+        logic = DetectorLogic.new node: self, id: id
+        @main.add_detector_logic logic
+        logic
+      end
+    end
+
+    def start_action
+      super
+      start_timer
+    end
+
+    def start_timer
+      task_name = "tlc timer"
+      log "Starting #{task_name} with interval #{@interval} seconds", level: :debug
+
+      @timer = @task.async do |task|
+        task.annotate task_name
+        next_time = Time.now.to_f
+        loop do
+          begin
+            now = RSMP.now_object
+            timer(now)
+          rescue EOFError => e
+            log "TLC timer: Connection closed: #{e}", level: :warning
+          rescue IOError => e
+            log "TLC timer: IOError", level: :warning
+          rescue Errno::ECONNRESET
+            log "TLC timer: Connection reset by peer", level: :warning
+          rescue Errno::EPIPE => e
+            log "TLC timer: Broken pipe", level: :warning
+          rescue StandardError => e
+            log "TLC timer: #{e}", level: :debug
+          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,
+            # 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
+            # if the clock is changed, the wake up would then happen on a different
+            # fractional second
+            next_time += @interval
+            duration = next_time - Time.now.to_f
+            task.sleep duration
+          end
+        end
+      end
+    end
+
+    def timer now
+      return unless @main
+      @main.timer now
+    end
+
+    def verify_security_code level, code
+      raise ArgumentError.new("Level must be 1-2, got #{level}") unless (1..2).include?(level)
+      if @security_codes[level] != code
+        raise MessageRejected.new("Wrong security code for level #{level}")
+      end
+    end
+
+    def change_security_code level, old_code, new_code
+      verify_security_code level, old_code
+      @security_codes[level] = new_code
+    end
+
+    def self.to_rmsp_bool bool
+      if bool
+        'True'
+      else
+        'False'
+      end
+    end
+
+    def self.from_rsmp_bool str
+      str == 'True'
+    end
+
+    def self.make_status value, q='recent'
+      case value
+      when true, false
+        return to_rmsp_bool(value), q
+      else
+        return value, q
+      end
+    end
+
+    def do_deferred item
+      case item
+      when :restart
+        log "Restarting TLC", level: :info
+        restart
+      end
+    end
+
+  end
+end