rsmp 0.37.0 → 0.38.0

data/lib/rsmp/tlc/modules/modes.rb

@@ -0,0 +1,253 @@
+module RSMP
+  module TLC
+    module Modules
+      # Operating modes and functional positions for traffic controllers
+      # Handles mode switching (NormalControl/YellowFlash/Dark) and control modes
+      module Modes
+        def reset_modes
+          @function_position = 'NormalControl'
+          @function_position_source = 'startup'
+          @previous_functional_position = nil
+          @functional_position_timeout = nil
+
+          @booting = false
+          @is_starting = false
+          @control_mode = 'control'
+          @manual_control = false
+          @manual_control_source = 'startup'
+          @fixed_time_control = false
+          @fixed_time_control_source = 'startup'
+          @isolated_control = false
+          @isolated_control_source = 'startup'
+          @all_red = false
+          @all_red_source = 'startup'
+          @police_key = 0
+        end
+
+        def check_functional_position_timeout
+          return unless @functional_position_timeout
+          return unless clock.now >= @functional_position_timeout
+
+          switch_functional_position @previous_functional_position, reverting: true, source: 'calendar_clock'
+          @functional_position_timeout = nil
+          @previous_functional_position = nil
+        end
+
+        def dark?
+          @function_position == 'Dark'
+        end
+
+        def yellow_flash?
+          @function_position == 'YellowFlash'
+        end
+
+        def normal_control?
+          @function_position == 'NormalControl'
+        end
+
+        # M0001 - Set functional position
+        def handle_m0001(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+
+          # timeout is specified in minutes, but we take 1 to mean 1s
+          # this is not according to the curent rsmp spec, but is done
+          # to speed up testing
+          timeout = arg['timeout'].to_i
+          if timeout == 1
+            timeout = 1
+          else
+            timeout *= 60
+          end
+
+          switch_functional_position arg['status'],
+                                     timeout: timeout,
+                                     source: 'forced'
+        end
+
+        # M0007 - Set fixed time control
+        def handle_m0007(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          set_fixed_time_control arg['status'], source: 'forced'
+        end
+
+        # M0005 - Enable/disable emergency route
+        def handle_m0005(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          route = arg['emergencyroute'].to_i
+          enable = (arg['status'] == 'True')
+          @last_emergency_route = route
+
+          if enable
+            if @emergency_routes.add? route
+              log "Enabling emergency route #{route}", level: :info
+            else
+              log "Emergency route #{route} already enabled", level: :info
+            end
+          elsif @emergency_routes.delete? route
+            log "Disabling emergency route #{route}", level: :info
+          else
+            log "Emergency route #{route} already disabled", level: :info
+          end
+        end
+
+        # S0007 - Intersection status
+        def handle_s0007(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status @function_position != 'Dark'
+          when 'source'
+            TrafficControllerSite.make_status @function_position_source
+          end
+        end
+
+        # S0008 - Manual control status
+        def handle_s0008(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status @manual_control
+          when 'source'
+            TrafficControllerSite.make_status @manual_control_source
+          end
+        end
+
+        # S0009 - Fixed time control status
+        def handle_s0009(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status @fixed_time_control
+          when 'source'
+            TrafficControllerSite.make_status @fixed_time_control_source
+          end
+        end
+
+        # S0010 - Isolated control status
+        def handle_s0010(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status @isolated_control
+          when 'source'
+            TrafficControllerSite.make_status @isolated_control_source
+          end
+        end
+
+        # S0011 - Yellow flash status
+        def handle_s0011(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status TrafficControllerSite.to_rmsp_bool(@function_position == 'YellowFlash')
+          when 'source'
+            TrafficControllerSite.make_status @function_position_source
+          end
+        end
+
+        # S0012 - All red status
+        def handle_s0012(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status @all_red
+          when 'source'
+            TrafficControllerSite.make_status @all_red_source
+          end
+        end
+
+        # S0013 - Police key status
+        def handle_s0013(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status @police_key
+          end
+        end
+
+        # S0020 - Control mode
+        def handle_s0020(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'controlmode'
+            TrafficControllerSite.make_status @control_mode
+          end
+        end
+
+        # S0032 - Coordination status
+        def handle_s0032(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'intersection'
+            TrafficControllerSite.make_status @intersection
+          when 'status'
+            TrafficControllerSite.make_status 'local'
+          when 'source'
+            TrafficControllerSite.make_status @intersection_source
+          end
+        end
+
+        # S0006 - Emergency route status (deprecated, use S0035)
+        def handle_s0006(_status_code, status_name = nil, options = {})
+          if Proxy.version_meets_requirement? options[:sxl_version],
+                                              '>=1.2.0'
+            log 'S0006 is depreciated, use S0035 instead.',
+                level: :warning
+          end
+          status = @emergency_routes.any?
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status status
+          when 'emergencystage'
+            TrafficControllerSite.make_status status ? @last_emergency_route : 0
+          end
+        end
+
+        # S0035 - Emergency routes (replaces S0006)
+        def handle_s0035(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'emergencyroutes'
+            list = @emergency_routes.sort.map { |route| { 'id' => route.to_s } }
+            TrafficControllerSite.make_status list
+          end
+        end
+
+        def set_fixed_time_control(status, source:)
+          @fixed_time_control = status
+          @fixed_time_control_source = source
+        end
+
+        def switch_functional_position(mode, source:, timeout: nil, reverting: false)
+          unless %w[NormalControl YellowFlash Dark].include? mode
+            raise RSMP::MessageRejected,
+                  "Invalid functional position #{mode.inspect}, must be NormalControl, YellowFlash or Dark"
+          end
+
+          if reverting
+            log "Reverting to functional position #{mode} after timeout", level: :info
+          elsif timeout&.positive?
+            log "Switching to functional position #{mode} with timeout #{(timeout / 60).round(1)}min", level: :info
+            @previous_functional_position = @function_position
+            now = clock.now
+            @functional_position_timeout = now + timeout
+          else
+            log "Switching to functional position #{mode}", level: :info
+          end
+          initiate_startup_sequence if (mode == 'NormalControl') && (@function_position != 'NormalControl')
+          @function_position = mode
+          @function_position_source = source
+          # Update signal group states immediately to reflect new functional position
+          @signal_groups.each(&:timer)
+          mode
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/tlc/modules/outputs.rb

@@ -0,0 +1,30 @@
+module RSMP
+  module TLC
+    module Modules
+      # Output management for traffic controller
+      # Handles output status queries and forcing
+      module Outputs
+        # M0020 - Force output
+        def handle_m0020(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+        end
+
+        # S0004 - Output status
+        def handle_s0004(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'outputstatus', 'extendedoutputstatus'
+            TrafficControllerSite.make_status 0
+          end
+        end
+
+        # S0030 - Forced output status
+        def handle_s0030(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/tlc/modules/plans.rb

@@ -0,0 +1,218 @@
+module RSMP
+  module TLC
+    module Modules
+      # Time plans, traffic situations, and scheduling management
+      # Handles time plan selection, dynamic bands, schedules, and cycle times
+      module Plans
+        def current_plan
+          # TODO: plan 0 should means use time table
+          return unless @plans
+
+          @plans[plan] || @plans.values.first
+        end
+
+        # M0002 - Set current time plan
+        def handle_m0002(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          if TrafficControllerSite.from_rsmp_bool?(arg['status'])
+            switch_plan arg['timeplan'], source: 'forced'
+          else
+            switch_plan 0, source: 'startup' # TODO: use clock/calender
+          end
+        end
+
+        # M0003 - Set traffic situation
+        def handle_m0003(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          switch_traffic_situation arg['traficsituation']
+        end
+
+        def find_plan(plan_nr)
+          plan = @plans[plan_nr.to_i]
+          raise InvalidMessage, "unknown signal plan #{plan_nr}, known only [#{@plans.keys.join(', ')}]" unless plan
+
+          plan
+        end
+
+        def switch_plan(plan, source:)
+          plan_nr = plan.to_i
+          if plan_nr.zero?
+            log 'Switching to plan selection by time table', level: :info
+          else
+            find_plan plan_nr
+            log "Switching to plan #{plan_nr}", level: :info
+          end
+          @plan = plan_nr
+          @plan_source = source
+        end
+
+        def switch_traffic_situation(situation)
+          @traffic_situation = situation.to_i
+          @traffic_situation_source = 'forced'
+        end
+
+        # M0014 - Set dynamic bands
+        def handle_m0014(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          plan = find_plan arg['plan']
+          arg['status'].split(',').each do |item|
+            matched = /(\d+)-(\d+)/.match item
+            band = matched[1].to_i
+            value = matched[2].to_i
+            log "Set plan #{arg['plan']} dynamic band #{band} to #{value}", level: :info
+            plan.set_band band, value
+          end
+        end
+
+        # M0015 - Set offset time
+        def handle_m0015(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+        end
+
+        # M0016 - Set week time table
+        def handle_m0016(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+        end
+
+        # M0017 - Set time tables
+        def handle_m0017(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          arg['status'].split(',').each do |item|
+            elems = item.split('-')
+            nr = elems[0].to_i
+            plan = elems[1].to_i
+            hour = elems[2].to_i
+            min = elems[3].to_i
+            raise InvalidMessage, "time table id must be between 0 and 12, got #{nr}" if nr.negative? || nr > 12
+
+            @day_time_table[nr] = { plan: plan, hour: hour, min: min }
+          end
+        end
+
+        # M0018 - Set cycle time
+        def handle_m0018(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          nr = arg['plan'].to_i
+          cycle_time = arg['status'].to_i
+          plan = @plans[nr]
+          raise RSMP::MessageRejected, "Plan '#{nr}' not found" unless plan
+          raise RSMP::MessageRejected, 'Cycle time must be greater or equal to zero' if cycle_time.negative?
+
+          log "Set plan #{nr} cycle time to #{cycle_time}", level: :info
+          plan.cycle_time = cycle_time
+        end
+
+        # M0023 - Dynamic bands timeout
+        def handle_m0023(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          timeout = arg['status'].to_i
+          unless (timeout >= 0) && (timeout <= 65_535)
+            raise RSMP::MessageRejected,
+                  "Timeout must be in the range 0-65535, got #{timeout}"
+          end
+
+          if timeout.zero?
+            log 'Dynamic bands timeout disabled', level: :info
+          else
+            log "Dynamic bands timeout set to #{timeout}min", level: :info
+          end
+          @dynamic_bands_timeout = timeout
+        end
+
+        # S0014 - Current signal program
+        def handle_s0014(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status @plan
+          when 'source'
+            TrafficControllerSite.make_status @plan_source
+          end
+        end
+
+        # S0015 - Current traffic situation
+        def handle_s0015(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status @traffic_situation
+          when 'source'
+            TrafficControllerSite.make_status @traffic_situation_source
+          end
+        end
+
+        # S0018 - Number of time plans
+        def handle_s0018(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'number'
+            TrafficControllerSite.make_status @plans.size
+          end
+        end
+
+        # S0019 - Number of traffic situations
+        def handle_s0019(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'number'
+            TrafficControllerSite.make_status @num_traffic_situations
+          end
+        end
+
+        # S0022 - List of time plans
+        def handle_s0022(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status @plans.keys.join(',')
+          end
+        end
+
+        # S0023 - Dynamic bands
+        def handle_s0023(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            dynamic_bands = @plans.map { |_nr, plan| plan.dynamic_bands_string }
+            str = dynamic_bands.compact.join(',')
+            TrafficControllerSite.make_status str
+          end
+        end
+
+        # S0024 - Offset times
+        def handle_s0024(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status '1-0'
+          end
+        end
+
+        # S0026 - Week time table
+        def handle_s0026(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status '0-00'
+          end
+        end
+
+        # S0027 - Time tables
+        def handle_s0027(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            status = @day_time_table.map do |i, item|
+              "#{i}-#{item[:plan]}-#{item[:hour]}-#{item[:min]}"
+            end.join(',')
+            TrafficControllerSite.make_status status
+          end
+        end
+
+        # S0028 - Cycle time
+        def handle_s0028(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            times = @plans.map do |_nr, plan|
+              "#{format('%02d', plan.number)}-#{format('%02d', plan.cycle_time)}"
+            end.join(',')
+            TrafficControllerSite.make_status times
+          end
+        rescue StandardError => e
+          puts e
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/tlc/modules/signal_groups.rb

@@ -0,0 +1,109 @@
+module RSMP
+  module TLC
+    module Modules
+      # Signal groups and signal priority management
+      # Handles signal group status and priority requests
+      module SignalGroups
+        def add_signal_group(group)
+          @signal_groups << group
+        end
+
+        def signal_priority_changed(priority, state); end
+
+        # remove all stale priority requests
+        def prune_priorities
+          @signal_priorities.delete_if(&:prune?)
+        end
+
+        def priority_list
+          @signal_priorities.map do |priority|
+            {
+              'r' => priority.id,
+              't' => RSMP::Clock.to_s(priority.updated),
+              's' => priority.state
+            }
+          end
+        end
+
+        # M0022 - Signal priority request
+        def handle_m0022(arg, _options = {})
+          id = arg['requestId']
+          type = arg['type']
+          priority = find_signal_priority(id)
+
+          case type
+          when 'new'
+            create_priority_request(id, priority, arg)
+          when 'update'
+            update_priority_request(id, priority)
+          when 'cancel'
+            cancel_priority_request(id, priority)
+          else
+            raise MessageRejected, "Unknown type #{type}"
+          end
+        end
+
+        private
+
+        def find_signal_priority(id)
+          @signal_priorities.find { |priority| priority.id == id }
+        end
+
+        def create_priority_request(id, existing_priority, arg)
+          raise MessageRejected, "Priority Request #{id} already exists" if existing_priority
+
+          signal_group = node.find_component arg['signalGroupId'] if arg['signalGroupId']
+          @signal_priorities << SignalPriority.new(
+            node: self,
+            id: id,
+            level: arg['level'],
+            eta: arg['eta'],
+            vehicle_type: arg['vehicleType']
+          )
+          log "Priority request #{id} for signal group #{signal_group.c_id} received.", level: :info
+        end
+
+        def update_priority_request(id, priority)
+          raise MessageRejected, "Cannot update priority request #{id}, not found" unless priority
+
+          log "Updating Priority Request #{id}", level: :info
+        end
+
+        def cancel_priority_request(id, priority)
+          raise MessageRejected, "Cannot cancel priority request #{id}, not found" unless priority
+
+          priority.cancel
+          log "Priority request with id #{id} cancelled.", level: :info
+        end
+
+        # S0001 - Signal group status
+        def handle_s0001(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'signalgroupstatus'
+            TrafficControllerSite.make_status format_signal_group_status
+          when 'cyclecounter', 'basecyclecounter'
+            TrafficControllerSite.make_status @cycle_counter.to_s
+          when 'stage'
+            TrafficControllerSite.make_status 0.to_s
+          end
+        end
+
+        # S0017 - Number of signal groups
+        def handle_s0017(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'number'
+            TrafficControllerSite.make_status @signal_groups.size
+          end
+        end
+
+        # S0033 - Signal priority status
+        def handle_s0033(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status priority_list
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/tlc/modules/startup_sequence.rb

@@ -0,0 +1,22 @@
+module RSMP
+  module TLC
+    module Modules
+      # Startup sequence management
+      module StartupSequence
+        def startup_state
+          @startup_sequence.current_state
+        end
+
+        def initiate_startup_sequence
+          log 'Initiating startup sequence', level: :info
+          reset_modes
+          @startup_sequence.start
+        end
+
+        def end_startup_sequence
+          @startup_sequence.stop
+        end
+      end
+    end
+  end
+end