rsmp 0.37.0 → 0.38.0

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

@@ -0,0 +1,140 @@
+module RSMP
+  module TLC
+    module Modules
+      # System-level commands and status for traffic controllers
+      # Handles restart, emergency routes, security, clock, version, and configuration
+      module System
+        def clock
+          node.clock
+        end
+
+        # M0004 - Restart traffic light controller
+        def handle_m0004(arg, _options = {})
+          @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
+
+        # M0103 - Set security code
+        def handle_m0103(arg, _options = {})
+          level = { 'Level1' => 1, 'Level2' => 2 }[arg['status']]
+          @node.change_security_code level, arg['oldSecurityCode'], arg['newSecurityCode']
+        end
+
+        # M0104 - Set clock
+        def handle_m0104(arg, _options = {})
+          @node.verify_security_code 1, arg['securityCode']
+          time = Time.new(
+            arg['year'],
+            arg['month'],
+            arg['day'],
+            arg['hour'],
+            arg['minute'],
+            arg['second'],
+            'UTC'
+          )
+          clock.set time
+          log "Clock set to #{time}, (adjustment is #{clock.adjustment}s)", level: :info
+        end
+
+        # S0005 - Traffic controller starting
+        def handle_s0005(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status @is_starting
+          when 'statusByIntersection' # from sxl 1.2.0
+            TrafficControllerSite.make_status([
+                                                {
+                                                  'intersection' => '1',
+                                                  'startup' => TrafficControllerSite.to_rmsp_bool(@is_starting)
+                                                }
+                                              ])
+          end
+        end
+
+        # S0095 - Version information
+        def handle_s0095(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'status'
+            TrafficControllerSite.make_status RSMP::VERSION
+          end
+        end
+
+        # S0091 - Operator logged in/out OP-panel
+        def handle_s0091(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'user'
+            TrafficControllerSite.make_status 0
+          when 'username'
+            TrafficControllerSite.make_status ''
+          end
+        end
+
+        # S0092 - Operator logged in/out web-interface
+        def handle_s0092(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'user'
+            TrafficControllerSite.make_status 0
+          when 'username'
+            TrafficControllerSite.make_status ''
+          end
+        end
+
+        def datetime_components
+          {
+            'year' => [4, :year],
+            'month' => [2, :month],
+            'day' => [2, :day],
+            'hour' => [2, :hour],
+            'minute' => [2, :min],
+            'second' => [2, :sec]
+          }
+        end
+
+        # S0096 - Current date and time
+        def handle_s0096(_status_code, status_name = nil, _options = {})
+          component = datetime_components[status_name]
+          return nil unless component
+
+          width, method = component
+          now = clock.now
+          TrafficControllerSite.make_status format_datetime_component(now.send(method), width)
+        end
+
+        private
+
+        def format_datetime_component(value, width)
+          value.to_s.rjust(width, '0')
+        end
+
+        # S0097 - Configuration checksum
+        def handle_s0097(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'checksum'
+            TrafficControllerSite.make_status '1'
+          when 'timestamp'
+            now = clock.to_s
+            TrafficControllerSite.make_status now
+          end
+        end
+
+        # S0098 - Configuration data
+        def handle_s0098(_status_code, status_name = nil, _options = {})
+          settings = node.site_settings.slice('components', 'signal_plans', 'inputs', 'startup_sequence')
+          json = JSON.generate(settings)
+          case status_name
+          when 'config'
+            TrafficControllerSite.make_status json
+          when 'timestamp'
+            now = clock.to_s
+            TrafficControllerSite.make_status now
+          when 'version'
+            TrafficControllerSite.make_status Digest::MD5.hexdigest(json)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module RSMP
+  module TLC
+    module Modules
+      # Traffic counting data collection for TLC
+      # Handles aggregate traffic counting status for all detectors
+      module TrafficData
+        # S0205 - Traffic Counting: Number of vehicles (aggregate)
+        def handle_s0205(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'start'
+            TrafficControllerSite.make_status clock.to_s
+          when 'vehicles'
+            TrafficControllerSite.make_status 0
+          end
+        end
+
+        # S0206 - Traffic Counting: Vehicle speed (aggregate)
+        def handle_s0206(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'start'
+            TrafficControllerSite.make_status clock.to_s
+          when 'speed'
+            TrafficControllerSite.make_status 0
+          end
+        end
+
+        # S0207 - Traffic Counting: Occupancy (aggregate)
+        def handle_s0207(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'start'
+            TrafficControllerSite.make_status clock.to_s
+          when 'occupancy'
+            TrafficControllerSite.make_status 0
+          end
+        end
+
+        # S0208 - Traffic Counting: Number of vehicles by classification (aggregate)
+        def handle_s0208(_status_code, status_name = nil, _options = {})
+          case status_name
+          when 'start'
+            TrafficControllerSite.make_status clock.to_s
+          when 'P', 'PS', 'L', 'LS', 'B', 'SP', 'MC', 'C', 'F'
+            TrafficControllerSite.make_status 0
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rsmp/tlc/signal_group.rb

@@ -4,8 +4,8 @@ module RSMP
       attr_reader :plan, :state
 
       # plan is a string, with each character representing a signal phase at a particular second in the cycle
-      def initialize node:, id:
-        super node: node, id: id, grouped: false
+      def initialize(node:, id:)
+        super(node: node, id: id, grouped: false)
       end
 
       def timer
@@ -15,82 +15,78 @@ module RSMP
       def compute_state
         return 'a' if node.main.dark?
         return 'c' if node.main.yellow_flash?
+        return startup_state if node.main.startup_sequence.active?
 
-        cycle_counter = node.main.cycle_counter
+        compute_plan_state
+      end
 
-        if node.main.startup_sequence_active
-          return node.main.startup_state || 'a'
-        end
+      def startup_state
+        node.main.startup_state || 'a'
+      end
 
-        default = 'a'   # phase a means disabled/dark
+      def compute_plan_state
+        default = 'a' # phase a means disabled/dark
         plan = node.main.current_plan
-        return default unless plan
-        return default unless plan.states
+        return default unless plan&.states
 
         states = plan.states[c_id]
         return default unless states
 
-        counter = [cycle_counter, states.length-1].min
+        state_at_cycle_position(states, node.main.cycle_counter, default)
+      end
+
+      def state_at_cycle_position(states, cycle_counter, default)
+        counter = [cycle_counter, states.length - 1].min
         state = states[counter]
-        return default unless state =~ /[a-hA-G0-9N-P]/  # valid signal group states
+        return default unless state =~ /[a-hA-G0-9N-P]/ # valid signal group states
+
         state
       end
 
-      def handle_command command_code, arg, options={}
+      def handle_command(command_code, arg, options = {})
         case command_code
         when 'M0010', 'M0011'
-          return send("handle_#{command_code.downcase}", arg, options)
+          send("handle_#{command_code.downcase}", arg, options)
         else
-          raise UnknownCommand.new "Unknown command #{command_code}"
+          raise UnknownCommand, "Unknown command #{command_code}"
         end
       end
 
       # Start of signal group. Orders a signal group to green
-      def handle_m0010 arg, options={}
+      def handle_m0010(arg, _options = {})
         @node.verify_security_code 2, arg['securityCode']
-        if TrafficControllerSite.from_rsmp_bool arg['status']
-          log "Start signal group #{c_id}, go to green", level: :info
-        end
+        return unless TrafficControllerSite.from_rsmp_bool? arg['status']
+
+        log "Start signal group #{c_id}, go to green", level: :info
       end
 
       # Stop of signal group. Orders a signal group to red
-      def handle_m0011 arg, options={}
+      def handle_m0011(arg, _options = {})
         @node.verify_security_code 2, arg['securityCode']
-        if TrafficControllerSite.from_rsmp_bool arg['status']
-          log "Stop signal group #{c_id}, go to red", level: :info
-        end
+        return unless TrafficControllerSite.from_rsmp_bool? arg['status']
+
+        log "Stop signal group #{c_id}, go to red", level: :info
       end
 
-      def get_status code, name=nil, options={}
+      def get_status(code, name = nil, _options = {})
         case code
         when 'S0025'
-          return send("handle_#{code.downcase}", code, name)
+          send("handle_#{code.downcase}", code, name)
         else
-          raise InvalidMessage.new "unknown status code #{code}"
+          raise InvalidMessage, "unknown status code #{code}"
         end
       end
 
-      def handle_s0025 status_code, status_name=nil, options={}
+      def handle_s0025(_status_code, status_name = nil, _options = {})
         now = @node.clock.to_s
         case status_name
-        when 'minToGEstimate'
-          TrafficControllerSite.make_status now
-        when 'maxToGEstimate'
-          TrafficControllerSite.make_status now
-        when 'likelyToGEstimate'
-          TrafficControllerSite.make_status now
-        when 'ToGConfidence'
-          TrafficControllerSite.make_status 0
-        when 'minToREstimate'
-          TrafficControllerSite.make_status now
-        when 'maxToREstimate'
-          TrafficControllerSite.make_status now
-        when 'likelyToREstimate'
+        when 'minToGEstimate', 'maxToGEstimate', 'likelyToGEstimate',
+             'minToREstimate', 'maxToREstimate', 'likelyToREstimate'
           TrafficControllerSite.make_status now
-        when 'ToRConfidence'
+        when 'ToGConfidence', 'ToRConfidence'
           TrafficControllerSite.make_status 0
         end
       end
     end
   end
-end
+end

data/lib/rsmp/tlc/signal_plan.rb

@@ -4,32 +4,35 @@ module RSMP
     # A signal plan is a description of how all signal groups should change
     # state over time.
     class SignalPlan
-      attr_reader :nr, :states, :dynamic_bands, :cycle_time
-      def initialize nr:, cycle_time:, states:, dynamic_bands:
-        @nr = nr
+      attr_reader :number, :states, :dynamic_bands, :cycle_time
+
+      def initialize(number:, cycle_time:, states:, dynamic_bands:)
+        @number = number
         @states = states
         @dynamic_bands = dynamic_bands || {}
         @cycle_time = cycle_time
       end
 
       def dynamic_bands_string
-        str = @dynamic_bands.map { |band,value| "#{nr}-#{band}-#{value}" }.join(',')
+        str = @dynamic_bands.map { |band, value| "#{@number}-#{band}-#{value}" }.join(',')
         return nil if str == ''
+
         str
       end
 
-      def set_band band, value
-        @dynamic_bands[ band.to_i ] = value.to_i
+      def set_band(band, value)
+        @dynamic_bands[band.to_i] = value.to_i
       end
 
-      def get_band band
-        @dynamic_bands[ band.to_i ]
+      def get_band(band)
+        @dynamic_bands[band.to_i]
       end
 
-      def set_cycle_time cycle_time
-        raise ArgumentError if cycle_time < 0
+      def cycle_time=(cycle_time)
+        raise ArgumentError if cycle_time.negative?
+
         @cycle_time = cycle_time
       end
     end
   end
-end
+end

data/lib/rsmp/tlc/signal_priority.rb

@@ -1,44 +1,48 @@
-class RSMP::TLC::SignalPriority
-  attr_reader :state, :node, :id, :level, :eta, :vehicleType, :age, :updated
+module RSMP
+  module TLC
+    class SignalPriority
+      attr_reader :state, :node, :id, :level, :eta, :vehicle_type, :age, :updated
 
-  def initialize node:, id:, level:, eta:, vehicleType:
-    @node = node
-    @id = id
-    @level = level
-    @eta = eta
-    @vehicleType = vehicleType
-    set_state 'received'
-  end
+      def initialize(node:, id:, level:, eta:, vehicle_type:)
+        @node = node
+        @id = id
+        @level = level
+        @eta = eta
+        @vehicle_type = vehicle_type
+        self.state = 'received'
+      end
 
-  def prune?
-    @state == 'stale' || @state == 'completed'
-  end
+      def prune?
+        @state == 'stale' || @state == 'completed'
+      end
 
-  def cancel
-    if @state == 'activated'
-      set_state 'completed'
-    end
-  end
+      def cancel
+        return unless @state == 'activated'
 
-  def set_state state
-    @state = state
-    @updated = node.clock.now
-    @node.signal_priority_changed self, @state
-  end
+        self.state = 'completed'
+      end
 
-  def timer
-    @age = @node.clock.now - @updated
-    case @state
-    when 'received'
-      if @age >= 0.5
-        @node.log "Priority request #{@id} activated.", level: :info
-        set_state 'activated'
+      def state=(state)
+        @state = state
+        @updated = node.clock.now
+        @node.signal_priority_changed self, @state
       end
-    when 'activated'
-      if @age >= 1
-        @node.log "Priority request #{@id} became stale.", level: :info
-        set_state 'stale'
+
+      def timer
+        @age = @node.clock.now - @updated
+        case @state
+        when 'received'
+          if @age >= 0.5
+            @node.log "Priority request #{@id} activated.", level: :info
+            self.state = 'activated'
+          end
+        when 'activated'
+          if @age >= 1
+            @node.log "Priority request #{@id} became stale.", level: :info
+            self.state = 'stale'
+          end
+        end
       end
     end
   end
-end
+end

data/lib/rsmp/tlc/startup_sequence.rb

@@ -0,0 +1,59 @@
+module RSMP
+  module TLC
+    # Manages startup sequence state machine for traffic controllers
+    class StartupSequence
+      attr_reader :sequence, :position, :initiated_at
+
+      def initialize(sequence)
+        @sequence = sequence || []
+        @active = false
+        @initiated_at = nil
+        @position = nil
+      end
+
+      def start
+        @active = true
+        @initiated_at = nil
+        @position = nil
+      end
+
+      def stop
+        @active = false
+        @initiated_at = nil
+        @position = nil
+      end
+
+      def active?
+        @active
+      end
+
+      def complete?
+        return false unless @active
+        return false if @position.nil?
+
+        @position >= @sequence.size
+      end
+
+      def current_state
+        return nil unless @active
+        return nil if @position.nil?
+        return nil if @position >= @sequence.size
+
+        @sequence[@position]
+      end
+
+      def advance
+        return unless @active
+
+        if @initiated_at.nil?
+          @initiated_at = Time.now.to_i + 1
+          @position = 0
+        else
+          @position = Time.now.to_i - @initiated_at
+        end
+
+        stop if complete?
+      end
+    end
+  end
+end