openc3 5.0.6

data/lib/openc3/packets/packet_item_limits.rb

@@ -0,0 +1,162 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/packets/limits_response'
+
+module OpenC3
+  # Maintains knowledge of limits for a PacketItem
+  class PacketItemLimits
+    # Array of all limit states
+    LIMITS_STATES = [:RED, :RED_HIGH, :RED_LOW, :YELLOW, :YELLOW_HIGH, :YELLOW_LOW, :GREEN, :GREEN_HIGH, :GREEN_LOW, :BLUE, :STALE, nil]
+    # Array of all limit states which should be considered in error
+    OUT_OF_LIMITS_STATES = [:RED, :RED_HIGH, :RED_LOW, :YELLOW, :YELLOW_HIGH, :YELLOW_LOW]
+
+    # Hash of arrays - Hash key is uppercase symbol designating limits set.
+    # :DEFAULT limits set is required if item has limits. nil indicates the
+    # item does not have limits. For defined limits, each array in the hash
+    # contains [:RED_LOW, :YELLOW_LOW, :YELLOW_HIGH, :RED_HIGH,
+    # :GREEN_LOW (optional), GREEN_HIGH (optional)].
+    # @return [Hash{Symbol=>Array}] Hash of all the limits defined for this
+    #   item. Must include a hash key of :DEFAULT which returns the default
+    #   limits.
+    attr_reader :values
+
+    # Every item effectively always has "limits" enabled because it can go from
+    # :STALE to nil as needed. This flag indicates whether an item with defined
+    # limit values can transition from nil to the various other states.
+    #
+    # @return [Boolean] Whether limits are enabled on this item
+    attr_accessor :enabled
+
+    # Current limits state of the item. One of nil, :STALE, :BLUE, :GREEN,
+    # :GREEN_HIGH, :GREEN_LOW, :YELLOW, :YELLOW_HIGH, :YELLOW_LOW,
+    # :RED, :RED_HIGH, :RED_LOW. Items initialize to :STALE and change states
+    # as the item value changes. If the limits are disabled the state changes
+    # to nil. If a packet becomes stale the items state changes to :STALE.
+    # @return [Symbol, nil] Current limits state of the item
+    attr_reader :state
+
+    # @return [LimitsResponse] Response method to be called on limits changes
+    attr_reader :response
+
+    # @return [Integer] Number of out of limits samples at which the limits
+    #   state will change
+    attr_reader :persistence_setting
+
+    # Current persistent count. The count will be reset to zero if the limits
+    # state hasn't changed (i.e. remained :GREEN).
+    # @return [Integer] Current running persistence count
+    attr_reader :persistence_count
+
+    # Create a PacketItemLimits
+    def initialize
+      @values = nil
+      @enabled = false
+      @state = :STALE
+      @response = nil
+      @persistence_setting = 1
+      @persistence_count = 0
+    end
+
+    def values=(values)
+      if values
+        raise ArgumentError, "values must be a Hash but is a #{values.class}" unless Hash === values
+        raise ArgumentError, "values must be a Hash with a :DEFAULT key" unless values.keys.include?(:DEFAULT)
+
+        @values = values.clone
+      else
+        @values = nil
+      end
+    end
+
+    def state=(state)
+      raise ArgumentError, "state must be one of #{LIMITS_STATES} but is #{state}" unless LIMITS_STATES.include?(state)
+
+      @state = state
+    end
+
+    def response=(response)
+      if response
+        raise ArgumentError, "response must be a OpenC3::LimitsResponse but is a #{response.class}" unless OpenC3::LimitsResponse === response
+
+        @response = response.clone
+      else
+        @response = nil
+      end
+    end
+
+    def persistence_setting=(persistence_setting)
+      if 0.class == Integer
+        # Ruby version >= 2.4.0
+        raise ArgumentError, "persistence_setting must be an Integer but is a #{persistence_setting.class}" unless Integer === persistence_setting
+      else
+        # Ruby version < 2.4.0
+        raise ArgumentError, "persistence_setting must be a Fixnum but is a #{persistence_setting.class}" unless Fixnum === persistence_setting
+      end
+      @persistence_setting = persistence_setting
+    end
+
+    def persistence_count=(persistence_count)
+      if 0.class == Integer
+        # Ruby version >= 2.4.0
+        raise ArgumentError, "persistence_count must be an Integer but is a #{persistence_count.class}" unless Integer === persistence_count
+      else
+        # Ruby version < 2.4.0
+        raise ArgumentError, "persistence_count must be a Fixnum but is a #{persistence_count.class}" unless Fixnum === persistence_count
+      end
+      @persistence_count = persistence_count
+    end
+
+    # Make a light weight clone of this limits
+    def clone
+      limits = super()
+      limits.values = self.values.clone if self.values
+      limits.response = self.response.clone if self.response
+      limits
+    end
+    alias dup clone
+
+    def as_json(*a)
+      hash = {}
+      hash['values'] = self.values
+      hash['enabled'] = self.enabled
+      hash['state'] = self.state
+      if self.response
+        hash['response'] = self.response.to_s
+      else
+        hash['response'] = nil
+      end
+      hash['persistence_setting'] = self.persistence_setting
+      hash['persistence_count'] = self.persistence_count
+      hash
+    end
+
+    def self.from_json(hash)
+      limits = PacketItemLimits.new
+      limits.values = hash['values'].transform_keys(&:to_sym) if hash['values']
+      limits.enabled = hash['enabled']
+      limits.state = hash['state'] ? hash['state'].to_sym : nil
+      # Can't recreate a LimitsResponse class
+      # limits.response = hash['response']
+      limits.persistence_setting = hash['persistence_setting'] if hash['persistence_setting']
+      limits.persistence_count = hash['persistence_count'] if hash['persistence_count']
+      limits
+    end
+  end
+end

data/lib/openc3/packets/parsers/format_string_parser.rb

@@ -0,0 +1,65 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  class FormatStringParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param item [Packet] The current item
+    def self.parse(parser, item)
+      @parser = FormatStringParser.new(parser)
+      @parser.verify_parameters()
+      @parser.create_format_string(item)
+    end
+
+    # @param parser [ConfigParser] Configuration parser
+    def initialize(parser)
+      @parser = parser
+    end
+
+    def verify_parameters
+      @usage = "FORMAT_STRING <PRINTF STYLE STRING>"
+      @parser.verify_num_parameters(1, 1, @usage)
+    end
+
+    # @param item [PacketItem] The item the limits response should be added to
+    def create_format_string(item)
+      item.format_string = @parser.parameters[0]
+      # Only test the format string if there is not a read conversion because
+      # read conversion can return any type
+      test_format_string(item) unless item.read_conversion
+    end
+
+    private
+
+    def test_format_string(item)
+      case item.data_type
+      when :INT, :UINT
+        sprintf(item.format_string, 0)
+      when :FLOAT
+        sprintf(item.format_string, 0.0)
+      when :STRING, :BLOCK
+        sprintf(item.format_string, 'Hello')
+      else
+        # Nothing to do
+      end
+    rescue Exception
+      raise @parser.error("Invalid FORMAT_STRING specified for type #{item.data_type}: #{@parser.parameters[0]}", @usage)
+    end
+  end
+end

data/lib/openc3/packets/parsers/limits_parser.rb

@@ -0,0 +1,159 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  class LimitsParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param packet [Packet] The current packet
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    # @param item [PacketItem] The packet item to create limits on
+    # @param warnings [Array<String>] Array of string warnings which will be
+    #   appended with any warnings found when parsing the limits
+    def self.parse(parser, packet, cmd_or_tlm, item, warnings)
+      raise parser.error("Items with STATE can't define LIMITS") if item.states
+
+      @parser = LimitsParser.new(parser)
+      @parser.verify_parameters(cmd_or_tlm)
+      @parser.create_limits(packet, item, warnings)
+    end
+
+    def initialize(parser)
+      @parser = parser
+    end
+
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def verify_parameters(cmd_or_tlm)
+      if cmd_or_tlm == PacketConfig::COMMAND
+        raise @parser.error("LIMITS only applies to telemetry items")
+      end
+
+      @usage = "LIMITS <LIMITS SET> <PERSISTENCE> <ENABLED/DISABLED> <RED LOW LIMIT> <YELLOW LOW LIMIT> <YELLOW HIGH LIMIT> <RED HIGH LIMIT> <GREEN LOW LIMIT (Optional)> <GREEN HIGH LIMIT (Optional)>"
+      @parser.verify_num_parameters(7, 9, @usage)
+    end
+
+    # @param packet [Packet] The packet the item should be added to
+    def create_limits(packet, item, warnings)
+      limits_set = get_limits_set()
+      initialize_limits_values(packet, item)
+      ensure_consistency_with_default(packet, item, warnings)
+
+      item.limits.values[limits_set] = get_values()
+      item.limits.enabled = get_enabled()
+      item.limits.persistence_setting = get_persistence()
+      item.limits.persistence_count = 0
+
+      packet.update_limits_items_cache(item)
+      limits_set
+    end
+
+    private
+
+    def initialize_limits_values(packet, item)
+      limits_set = get_limits_set()
+      # Values must be initialized with a :DEFAULT key
+      if !item.limits.values
+        if limits_set == :DEFAULT
+          item.limits.values = { :DEFAULT => [] }
+        else
+          raise @parser.error("DEFAULT limits set must be defined for #{packet.target_name} #{packet.packet_name} #{item.name} before setting limits set #{limits_set}")
+        end
+      end
+    end
+
+    def ensure_consistency_with_default(packet, item, warnings)
+      # Nothing to do if we're already :DEFAULT
+      return if get_limits_set() == :DEFAULT
+
+      msg = "TELEMETRY Item #{packet.target_name} #{packet.packet_name} #{item.name} #{get_limits_set()} limits _TYPE_ setting conflict with DEFAULT"
+      # XOR our setting with the items current setting
+      # If it returns true then we have a mismatch and log the error
+      if get_enabled() ^ item.limits.enabled
+        warnings << msg.sub('_TYPE_', 'enable')
+        Logger.instance.warn warnings[-1]
+      end
+      if item.limits.persistence_setting != get_persistence()
+        warnings << msg.sub('_TYPE_', 'persistence')
+        Logger.instance.warn warnings[-1]
+      end
+    end
+
+    def get_limits_set
+      @parser.parameters[0].upcase.to_sym
+    end
+
+    def get_persistence
+      Integer(@parser.parameters[1])
+    rescue
+      raise @parser.error("Persistence must be an integer.", @usage)
+    end
+
+    def get_enabled
+      enabled = @parser.parameters[2].upcase
+      if enabled != 'ENABLED' and enabled != 'DISABLED'
+        raise @parser.error("Initial LIMITS state must be ENABLED or DISABLED.", @usage)
+      end
+
+      enabled == 'ENABLED' ? true : false
+    end
+
+    def get_values
+      values = get_red_yellow_values()
+      values += get_green_values(values[1], values[2])
+      values
+    end
+
+    def get_red_yellow_values
+      params = @parser.parameters
+      err = nil
+      red_low = Float(params[3]) rescue err = "red low"
+      yellow_low = Float(params[4]) rescue err = "yellow low"
+      yellow_high = Float(params[5]) rescue err = "yellow high"
+      red_high = Float(params[6]) rescue err = "red high"
+      raise @parser.error("Invalid #{err} limit value. Limits can be integers or floats.", @usage) if err
+
+      # Verify valid limits are specified
+      if (red_low > yellow_low) or (yellow_low >= yellow_high) or (yellow_high > red_high)
+        raise @parser.error("Invalid limits specified. Ensure yellow limits are within red limits.", @usage)
+      end
+
+      [red_low, yellow_low, yellow_high, red_high]
+    end
+
+    def get_green_values(yellow_low, yellow_high)
+      params = @parser.parameters
+      # Since our initial parameter check verifies between 7 and 9 we do a
+      # special check for 8 parameters which is an error
+      if params.length == 8
+        raise @parser.error("Must give both a green low and green high value.", @usage)
+      end
+      return [] unless params.length == 9
+
+      err = nil
+      green_low = Float(params[7]) rescue err = "green low"
+      green_high = Float(params[8]) rescue err = "green high"
+      raise @parser.error("Invalid #{err} limit value. Limits can be integers or floats.", @usage) if err
+
+      if (yellow_low > green_low) or (green_low >= green_high) or (green_high > yellow_high)
+        raise @parser.error("Invalid limits specified. Ensure green limits are within yellow limits.", @usage)
+      end
+
+      [green_low, green_high]
+    end
+  end
+end

data/lib/openc3/packets/parsers/limits_response_parser.rb

@@ -0,0 +1,61 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+module OpenC3
+  class LimitsResponseParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param item [Packet] The current item
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def self.parse(parser, item, cmd_or_tlm)
+      @parser = LimitsResponseParser.new(parser)
+      @parser.verify_parameters(cmd_or_tlm)
+      @parser.create_limits_response(item)
+    end
+
+    # @param parser [ConfigParser] Configuration parser
+    def initialize(parser)
+      @parser = parser
+    end
+
+    # @param cmd_or_tlm [String] Whether this is a command or telemetry packet
+    def verify_parameters(cmd_or_tlm)
+      if cmd_or_tlm == PacketConfig::COMMAND
+        raise @parser.error("LIMITS_RESPONSE only applies to telemetry items")
+      end
+
+      @usage = "LIMITS_RESPONSE <RESPONSE CLASS FILENAME> <RESPONSE SPECIFIC OPTIONS>"
+      @parser.verify_num_parameters(1, nil, @usage)
+    end
+
+    # @param item [PacketItem] The item the limits response should be added to
+    def create_limits_response(item)
+      # require should be performed in target.txt
+      klass = @parser.parameters[0].filename_to_class_name.to_class
+      raise @parser.error("#{@parser.parameters[0].filename_to_class_name} class not found. Did you require the file in target.txt?", @usage) unless klass
+
+      if @parser.parameters[1]
+        item.limits.response = klass.new(*@parser.parameters[1..(@parser.parameters.length - 1)])
+      else
+        item.limits.response = klass.new
+      end
+    rescue Exception => err
+      raise @parser.error(err, @usage)
+    end
+  end
+end