rsmp 0.37.0 → 0.38.0

data/lib/rsmp/tlc/input_states.rb

@@ -0,0 +1,126 @@
+module RSMP
+  module TLC
+    # class that maintains the state of TLC inputs
+    # indexing is 1-based since that's how the RSMP messages are specified
+    class InputStates
+      attr_reader :size
+
+      def initialize(size)
+        @size = size
+        reset
+      end
+
+      def reset
+        string_size = @size + 1
+        @value = '0' * string_size
+        @forced = '0' * string_size
+        @forced_value = '0' * string_size
+        @actual = '0' * string_size
+      end
+
+      def set(input, value)
+        check_input input
+        report_change(input) do
+          @value[input] = to_digit value
+          update_actual input
+        end
+      end
+
+      def set_forcing(input, force: true, forced_value: true)
+        check_input input
+        report_change(input) do
+          @forced[input] = to_digit force
+          @forced_value[input] = to_digit forced_value
+          update_actual input
+        end
+      end
+
+      def force(input, forced_value: true)
+        report_change(input) do
+          set_forcing input, force: true, forced_value: forced_value
+        end
+      end
+
+      def release(input)
+        report_change(input) do
+          set_forcing input, force: false, forced_value: false
+        end
+      end
+
+      def value?(input)
+        check_input input
+        from_digit? @value[input]
+      end
+
+      def forced?(input)
+        check_input input
+        from_digit? @forced[input]
+      end
+
+      def forced_value?(input)
+        check_input input
+        from_digit? @forced_value[input]
+      end
+
+      def actual?(input)
+        check_input input
+        from_digit? @actual[input]
+      end
+
+      def report(input)
+        {
+          value: value?(input),
+          forced: forced?(input),
+          forced_value: forced_value?(input),
+          actual: actual?(input)
+        }
+      end
+
+      def value_string
+        @value[1..]
+      end
+
+      def forced_string
+        @forced[1..]
+      end
+
+      def forced_value_string
+        @forced[1..]
+      end
+
+      def actual_string
+        @actual[1..]
+      end
+
+      protected
+
+      def check_input(input)
+        raise ArgumentError, "Input index #{input} must be in the range 1-#{@size}" if input < 1 || input > @size
+      end
+
+      def from_digit?(input)
+        input == '1'
+      end
+
+      def to_digit(input)
+        input ? '1' : '0'
+      end
+
+      def update_actual(input)
+        @actual[input] = if from_digit? @forced[input]
+                           @forced_value[input]
+                         else
+                           @value[input]
+                         end
+      end
+
+      def report_change(input)
+        before = @actual[input]
+        yield
+        return unless @actual[input] != before
+
+        from_digit? @actual[input]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module RSMP
+  module TLC
+    module Modules
+      # Detector logic management for traffic controller
+      # Handles detector logic status queries and forcing
+      module DetectorLogics
+        def add_detector_logic(logic)
+          @detector_logics << logic
+        end
+
+        # M0021 - Force detector logic
+        def handle_m0021(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+        end
+
+        # S0002 - Detector logic status
+        def handle_s0002(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'detectorlogicstatus'
+            TrafficControllerSite.make_status @detector_logics.map { |dl| bool_to_digit(dl.value) }.join
+          end
+        end
+
+        # S0016 - Number of detector logics
+        def handle_s0016(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'number'
+            TrafficControllerSite.make_status @detector_logics.size
+          end
+        end
+
+        # S0021 - Detector logic forcing status
+        def handle_s0021(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'detectorlogics'
+            TrafficControllerSite.make_status @detector_logics.map { |logic| bool_to_digit(logic.forced) }.join
+          end
+        end
+
+        # S0031 - Trigger level sensitivity for loop detector
+        def handle_s0031(_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/display.rb

@@ -0,0 +1,78 @@
+module RSMP
+  module TLC
+    module Modules
+      # Display and output formatting
+      module Display
+        def output_states
+          return unless @live_output
+
+          str = format_colored_signal_states
+          modes = format_mode_indicators
+          plan = "P#{@plan}"
+
+          write_state_output(modes, plan, str)
+        end
+
+        def format_signal_group_status
+          @signal_groups.map(&:state).join
+        end
+
+        private
+
+        def format_colored_signal_states
+          @signal_groups.map do |group|
+            state = group.state
+            s = "#{group.c_id}:#{state}"
+            colorize_signal_state(s, state)
+          end.join ' '
+        end
+
+        def colorize_signal_state(display_string, state)
+          case state
+          when /^[1-9]$/
+            display_string.colorize(:green)
+          when /^[NOPf]$/
+            display_string.colorize(:yellow)
+          when /^[ae]$/
+            display_string.colorize(:light_black)
+          else # includes /^g$/ and any other values
+            display_string.colorize(:red)
+          end
+        end
+
+        def mode_indicators
+          {
+            0 => ['N', @function_position == 'NormalControl'],
+            1 => ['Y', @function_position == 'YellowFlash'],
+            2 => ['D', @function_position == 'Dark'],
+            3 => ['B', @booting],
+            4 => ['S', @startup_sequence.active?],
+            5 => ['M', @manual_control],
+            6 => ['F', @fixed_time_control],
+            7 => ['R', @all_red],
+            8 => ['I', @isolated_control],
+            9 => ['P', @police_key != 0]
+          }
+        end
+
+        def format_mode_indicators
+          modes = '.' * 10
+          mode_indicators.each do |pos, (char, active)|
+            modes[pos] = char if active
+          end
+          modes
+        end
+
+        def write_state_output(modes, plan, signal_states)
+          # create folders if needed
+          FileUtils.mkdir_p File.dirname(@live_output)
+
+          # append a line with the current state to the file
+          File.open @live_output, 'w' do |file|
+            file.puts "#{modes}  #{plan.rjust(2)}  #{@cycle_counter.to_s.rjust(3)}  #{signal_states}\r"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module RSMP
+  module TLC
+    module Modules
+      # Utility helper methods
+      module Helpers
+        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 string_to_bool(bool_str)
+          case bool_str
+          when 'True'
+            true
+          when 'False'
+            false
+          else
+            raise RSMP::MessageRejected, "Invalid boolean '#{bool}', must be 'True' or 'False'"
+          end
+        end
+
+        def bool_string_to_digit(bool)
+          case bool
+          when 'True'
+            '1'
+          when 'False'
+            '0'
+          else
+            raise RSMP::MessageRejected, "Invalid boolean '#{bool}', must be 'True' or 'False'"
+          end
+        end
+
+        def bool_to_digit(bool)
+          bool ? '1' : '0'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+module RSMP
+  module TLC
+    module Modules
+      # Input programming, control, and status for traffic controllers
+      # Handles input commands and queries
+      module Inputs
+        def setup_inputs(inputs)
+          if inputs
+            num_inputs = inputs['total']
+            @input_programming = inputs['programming']
+          else
+            @input_programming = nil
+          end
+          @inputs = TLC::InputStates.new num_inputs || 8
+        end
+
+        def input_logic(input, change)
+          return unless @input_programming && !change.nil?
+
+          action = @input_programming[input]
+          return unless action
+
+          return unless action['raise_alarm']
+
+          component = if action['component']
+                        node.find_component action['component']
+                      else
+                        node.main
+                      end
+          alarm_code = action['raise_alarm']
+          if change
+            log "Activating input #{input} is programmed to raise alarm #{alarm_code} on #{component.c_id}",
+                level: :info
+            component.activate_alarm alarm_code
+          else
+            log "Deactivating input #{input} is programmed to clear alarm #{alarm_code} on #{component.c_id}",
+                level: :info
+            component.deactivate_alarm alarm_code
+          end
+        end
+
+        # M0006 - Set input
+        def handle_m0006(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          input = arg['input'].to_i
+          status = string_to_bool arg['status']
+          raise MessageRejected, "Input must be in the range 1-#{@inputs.size}" unless input.between?(1, @inputs.size)
+
+          if status
+            log "Activating input #{input}", level: :info
+          else
+            log "Deactivating input #{input}", level: :info
+          end
+          change = @inputs.set input, status
+          input_logic input, change unless change.nil?
+        end
+
+        # M0012 - Set input (simple)
+        def handle_m0012(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+        end
+
+        # M0013 - Set input (complex bit pattern)
+        def handle_m0013(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          set, clear = parse_input_status(arg['status'])
+          validate_input_ranges(set, clear)
+          apply_input_changes(set, clear)
+        end
+
+        # Helper: Parse input status string into set and clear arrays
+        def parse_input_status(status_string)
+          set = []
+          clear = []
+          status_string.split(';').each do |part|
+            offset, set_bits, clear_bits = part.split(',').map(&:to_i)
+            extract_input_bits(set_bits, offset, set)
+            extract_input_bits(clear_bits, offset, clear)
+          end
+
+          set = set.uniq.sort
+          clear = clear.uniq.sort
+          # if input is both activated and deactivated, there is no need to activate first
+          set -= (set & clear)
+
+          [set, clear]
+        end
+
+        # Helper: Extract individual input bits from a bit pattern
+        def extract_input_bits(bits, offset, target_array)
+          bits.to_s(2).reverse.each_char.with_index do |bit, i|
+            target_array << (i + offset) if bit == '1'
+          end
+        end
+
+        # Helper: Validate that input indices are in valid range
+        def validate_input_ranges(set, clear)
+          [set, clear].each do |inputs|
+            inputs.each do |input|
+              if input < 1
+                raise MessageRejected,
+                      "Cannot activate inputs #{set} and deactivate inputs #{clear}: " \
+                      "input #{input} is invalid (must be 1 or higher)"
+              end
+              next unless input > @inputs.size
+
+              raise MessageRejected,
+                    "Cannot activate inputs #{set} and deactivate inputs #{clear}: " \
+                    "input #{input} is invalid (only #{@inputs.size} inputs present)"
+            end
+          end
+        end
+
+        # Helper: Apply input changes (activate/deactivate)
+        def apply_input_changes(set, clear)
+          log "Activating inputs #{set} and deactivating inputs #{clear}", level: :info
+
+          set.each do |input|
+            change = @inputs.set input, true
+            input_logic input, change unless change.nil?
+          end
+          clear.each do |input|
+            change = @inputs.set input, false
+            input_logic input, change unless change.nil?
+          end
+        end
+
+        # Helper: Set a specific input value
+        def set_input(input_index, _value)
+          return unless input_index >= 0 && input_index < @num_inputs
+
+          @inputs[input_index] = bool_to_digit arg['value']
+        end
+
+        # M0019 - Force input
+        def handle_m0019(arg, _options = {})
+          @node.verify_security_code 2, arg['securityCode']
+          input = arg['input'].to_i
+          force = string_to_bool arg['status']
+          forced_value = string_to_bool arg['inputValue']
+          raise MessageRejected, "Input must be in the range 1-#{@inputs.size}" unless input.between?(1, @inputs.size)
+
+          if force
+            log "Forcing input #{input} to #{forced_value}", level: :info
+          else
+            log "Releasing input #{input}", level: :info
+          end
+          change = @inputs.set_forcing input, force: force, forced_value: forced_value
+
+          input_logic input, change unless change.nil?
+        end
+
+        # S0003 - Input status
+        def handle_s0003(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'inputstatus'
+            TrafficControllerSite.make_status @inputs.actual_string
+          when 'extendedinputstatus'
+            TrafficControllerSite.make_status 0.to_s
+          end
+        end
+
+        # S0029 - Forced input status
+        def handle_s0029(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status @inputs.forced_string
+          end
+        end
+      end
+    end
+  end
+end