Clock

Tests

Clock can be read with S0096

Verify status 0096 current date and time

  1. Given the site is connected
  2. Request status
  3. Expect status response before timeout
View Source 
it 'can be read with S0096' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.request_status_and_collect({ S0096: %i[year month day hour minute second] },
                                          within: RSMP::Validator.get_config('timeouts', 'status_response')).value!
  end
end

Clock can be set with M0104

Verify that the controller responds to M0104

  1. Given the site is connected
  2. Send command
  3. Expect status response before timeout
View Source 
it 'can be set with M0104' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    timeout = RSMP::Validator.get_config('timeouts', 'command_response')
    site_proxy.tlc.set_clock!(clock, within: timeout)
  end
end

Clock is used for M0001 response timestamp

Verify command response timestamp after changing clock

  1. Given the site is connected
  2. Send control command to set clock
  3. Send command to set functional position
  4. Compare set_clock and response timestamp
  5. Expect the difference to be within max_diff
View Source 
it 'is used for M0001 response timestamp' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
      with_clock_set site_proxy, clock, within: timeout do
        exchange = site_proxy.tlc.set_functional_position!('NormalControl', within: timeout)
        max_diff = timeout * 2
        diff = Time.parse(exchange.messages.first.attributes['cTS']) - clock
        diff = diff.round
        assert(diff.abs <= max_diff,
               "Timestamp of command response is off by #{diff}s, should be within #{max_diff}s")
      end
    end
  end
end

Clock is used for M0104 response timestamp

Verify command response timestamp after changing clock

  1. Given the site is connected
  2. Send control command to set clock
  3. Send command to set functional position
  4. Compare set_clock and response timestamp
  5. Expect the difference to be within max_diff
View Source 
it 'is used for M0104 response timestamp' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
      with_clock_set site_proxy, clock, within: timeout do
        exchange = site_proxy.tlc.set_functional_position!('NormalControl', within: timeout)
        max_diff = timeout
        diff = Time.parse(exchange.messages.first.attributes['cTS']) - clock
        diff = diff.round
        assert(diff.abs <= max_diff,
               "Timestamp of command response is off by #{diff}s, should be within #{max_diff}s")
      end
    end
  end
end

Clock is used for S0096 response timestamp

Verify status response timestamp after changing clock

  1. Given the site is connected
  2. Send control command to set_clock
  3. Request status S0096
  4. Compare set_clock and response timestamp
  5. Expect the difference to be within max_diff
View Source 
it 'is used for S0096 response timestamp' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      with_clock_set site_proxy, clock, within: RSMP::Validator.get_config('timeouts', 'command_response') do
        status_list = { S0096: %i[
          year
          month
          day
          hour
          minute
          second
        ] }
        timeout = RSMP::Validator.get_config('timeouts', 'status_response')
        exchange = site_proxy.request_status_and_collect(status_list,
                                                         within: timeout).value!
        max_diff = RSMP::Validator.get_config('timeouts', 'command_response') + timeout
        diff = Time.parse(exchange.messages.first.attributes['sTs']) - clock
        diff = diff.round
        assert(diff.abs <= max_diff,
               "Timestamp of S0096 is off by #{diff}s, should be within #{max_diff}s")
      end
    end
  end
end

Clock is used for S0096 status response

Verify status S0096 clock after changing clock

  1. Given the site is connected
  2. Send control command to set_clock
  3. Request status S0096
  4. Compare set_clock and status timestamp
  5. Expect the difference to be within max_diff
View Source 
it 'is used for S0096 status response' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      command_timeout = RSMP::Validator.get_config('timeouts', 'command_response')
      with_clock_set site_proxy, clock, within: command_timeout do
        status_list = { S0096: %i[
          year
          month
          day
          hour
          minute
          second
        ] }
        timeout = RSMP::Validator.get_config('timeouts', 'status_update')
        exchange = site_proxy.request_status_and_collect(
          status_list,
          within: timeout
        ).value!
        values = exchange.reached.to_h { |item| [item['n'], item['s']] }
        received = Time.new(
          values.fetch('year'),
          values.fetch('month'),
          values.fetch('day'),
          values.fetch('hour'),
          values.fetch('minute'),
          values.fetch('second'),
          'UTC'
        )
        max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
                   RSMP::Validator.get_config('timeouts', 'status_response')
        diff = received - clock
        diff = diff.round
        assert(diff.abs <= max_diff,
               "Clock reported by S0096 is off by #{diff}s, should be within #{max_diff}s")
      end
    end
  end
end

Clock is used for aggregated status timestamp

Verify aggregated status response timestamp after changing clock

  1. Given the site is connected
  2. Send control command to set clock
  3. Wait for status = true
  4. Request aggregated status
  5. Compare set_clock and response timestamp
  6. Expect the difference to be within max_diff
View Source 
it 'is used for aggregated status timestamp' do
  skip 'requires core >= 3.1.5' unless RSMP::Validator.core_matches?('>=3.1.5')
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      with_clock_set site_proxy, clock, within: RSMP::Validator.get_config('timeouts', 'command_response') do
        component = RSMP::Validator.get_config('main_component')
        timeout = RSMP::Validator.get_config('timeouts', 'status_response')
        exchange = site_proxy.request_aggregated_status_and_collect(component, within: timeout).value!
        max_diff = RSMP::Validator.get_config('timeouts', 'command_response') + timeout
        diff = Time.parse(exchange.messages.first.attributes['aSTS']) - clock
        diff = diff.round
        assert(diff.abs <= max_diff,
               "Timestamp of aggregated status is off by #{diff}s, should be within #{max_diff}s")
      end
    end
  end
end

Clock is used for alarm timestamp

View Source 
it 'is used for alarm timestamp' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      command_timeout = RSMP::Validator.get_config('timeouts', 'command_response')
      with_clock_set site_proxy, clock, within: command_timeout do # set clock
        with_alarm_activated(site_proxy, 'A0302') do |alarm| # raise alarm, by activating input
          alarm_time = Time.parse(alarm.attributes['aTs'])
          max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
                     RSMP::Validator.get_config('timeouts', 'status_response')
          diff = alarm_time - clock
          assert(diff.round.abs <= max_diff,
                 "Timestamp of alarm is off by #{diff}s, should be within #{max_diff}s")
        end
      end
    end
  end
end

Clock is used for watchdog timestamp

Verify timestamp of watchdog after changing clock

  1. Given the site is connected
  2. Send control command to setset_clock
  3. Wait for Watchdog
  4. Compare set_clock and alarm response timestamp
  5. Expect the difference to be within max_diff
View Source 
it 'is used for watchdog timestamp' do
  with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
    site_proxy.with_watchdog_disabled do # avoid time synchronization by disabling watchdogs
      with_clock_set site_proxy, clock, within: RSMP::Validator.get_config('timeouts', 'command_response') do
        log 'Checking watchdog timestamp'
        watchdog_timeout = RSMP::Validator.get_config('timeouts', 'watchdog')
        collector = RSMP::Collector.new(
          site_proxy,
          filter: RSMP::Filter.new(type: 'Watchdog'),
          num: 1,
          timeout: watchdog_timeout
        )
        collector.collect!
        max_diff = RSMP::Validator.get_config('timeouts', 'command_response') +
                   RSMP::Validator.get_config('timeouts', 'status_response')
        diff = Time.parse(collector.messages.first.attributes['wTs']) - clock
        diff = diff.round
        assert(diff.abs <= max_diff,
               "Timestamp of watchdog is off by #{diff}s, should be within #{max_diff}s")
      end
    end
  end
end
This site uses Just the Docs, a documentation theme for Jekyll.