cosmos 3.5.1 → 3.5.2

data/lib/cosmos/packets/packet_item_limits.rb

@@ -1,128 +1,128 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-require 'cosmos/packets/limits_response'
-
-module Cosmos
-
-  # 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 Cosmos::LimitsResponse but is a #{response.class}" unless Cosmos::LimitsResponse === response
-        @response = response.clone
-      else
-        @response = nil
-      end
-    end
-
-    def persistence_setting=(persistence_setting)
-      raise ArgumentError, "persistence_setting must be a Fixnum but is a #{persistence_setting.class}" unless Fixnum === persistence_setting
-      @persistence_setting = persistence_setting
-    end
-
-    def persistence_count=(persistence_count)
-      raise ArgumentError, "persistence_count must be a Fixnum but is a #{persistence_count.class}" unless Fixnum === persistence_count
-      @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 to_hash
-      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
-
-  end
-end # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/packets/limits_response'
+
+module Cosmos
+
+  # 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 Cosmos::LimitsResponse but is a #{response.class}" unless Cosmos::LimitsResponse === response
+        @response = response.clone
+      else
+        @response = nil
+      end
+    end
+
+    def persistence_setting=(persistence_setting)
+      raise ArgumentError, "persistence_setting must be a Fixnum but is a #{persistence_setting.class}" unless Fixnum === persistence_setting
+      @persistence_setting = persistence_setting
+    end
+
+    def persistence_count=(persistence_count)
+      raise ArgumentError, "persistence_count must be a Fixnum but is a #{persistence_count.class}" unless Fixnum === persistence_count
+      @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 to_hash
+      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
+
+  end
+end # module Cosmos

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

@@ -1,58 +1,58 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-module Cosmos
-
-  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 # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+module Cosmos
+
+  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 # module Cosmos

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

@@ -1,146 +1,146 @@
-# encoding: ascii-8bit
-
-# Copyright 2014 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 General Public License
-# as published by the Free Software Foundation; version 3 with
-# attribution addendums as found in the LICENSE.txt
-
-module Cosmos
-
-  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)
-      @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 # module Cosmos
+# encoding: ascii-8bit
+
+# Copyright 2014 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 General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+module Cosmos
+
+  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)
+      @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 # module Cosmos