openc3 6.5.1 → 6.7.0

data/lib/openc3/models/cvt_model.rb

@@ -14,12 +14,14 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2025, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
+require 'pg'
+require 'thread'
 require 'openc3/utilities/store'
 require 'openc3/utilities/store_queued'
 require 'openc3/models/target_model'
@@ -28,6 +30,8 @@ module OpenC3
   class CvtModel
     @@packet_cache = {}
     @@override_cache = {}
+    @@conn = nil
+    @@conn_mutex = Mutex.new
 
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
     def self.build_json_from_packet(packet)
@@ -117,22 +121,149 @@ module OpenC3
       end
     end
 
+    def self.tsdb_lookup(items, start_time:, end_time: nil)
+      tables = {}
+      names = []
+      nil_count = 0
+      items.each do |item|
+        target_name, packet_name, item_name, value_type, limits = item
+        # They will all be nil when item is a nil value
+        # A nil value indicates a value that does not exist as returned by get_tlm_available
+        if item_name.nil?
+          # We know timestamp always exists so we can use it to fill in the nil value
+          names << "timestamp as __nil#{nil_count}"
+          nil_count += 1
+          next
+        end
+        # See https://questdb.com/docs/reference/api/ilp/advanced-settings/#name-restrictions
+        table_name = "#{target_name}__#{packet_name}".gsub(/[?,'"\/:\)\(\+\*\%~]/, '_')
+        tables[table_name] = 1
+        index = tables.find_index {|k,v| k == table_name }
+        # See https://questdb.com/docs/reference/api/ilp/advanced-settings/#name-restrictions
+        # NOTE: Semicolon added as it appears invalid
+        item_name = item_name.gsub(/[?\.,'"\\\/:\)\(\+\-\*\%~;]/, '_')
+        case value_type
+        when 'WITH_UNITS'
+          names << "\"T#{index}.#{item_name}__U\""
+        when 'FORMATTED'
+          names << "\"T#{index}.#{item_name}__F\""
+        when 'CONVERTED'
+          names << "\"T#{index}.#{item_name}__C\""
+        else
+          names << "\"T#{index}.#{item_name}\""
+        end
+        if limits
+          names << "\"T#{index}.#{item_name}__L\""
+        end
+      end
+
+      # Build the SQL query
+      query = "SELECT #{names.join(", ")} FROM "
+      tables.each_with_index do |(table_name, _), index|
+        if index == 0
+          query += "#{table_name} as T#{index} "
+        else
+          query += "ASOF JOIN #{table_name} as T#{index} "
+        end
+      end
+      if start_time && !end_time
+        query += "WHERE T0.timestamp < '#{start_time}' LIMIT -1"
+      elsif start_time && end_time
+        query += "WHERE T0.timestamp >= '#{start_time}' AND T0.timestamp < '#{end_time}'"
+      end
+
+      retry_count = 0
+      begin
+        @@conn_mutex.synchronize do
+          @@conn ||= PG::Connection.new(host: ENV['OPENC3_TSDB_HOSTNAME'],
+                                        port: ENV['OPENC3_TSDB_QUERY_PORT'],
+                                        user: ENV['OPENC3_TSDB_USERNAME'],
+                                        password: ENV['OPENC3_TSDB_PASSWORD'],
+                                        dbname: 'qdb')
+          # Default connection is all strings but we want to map to the correct types
+          if @@conn.type_map_for_results.is_a? PG::TypeMapAllStrings
+            # TODO: This doesn't seem to be round tripping UINT64 correctly
+            # Try playback with P_2.2,2 and P(:6;): from the DEMO
+            @@conn.type_map_for_results = PG::BasicTypeMapForResults.new @@conn
+          end
+
+          result = @@conn.exec(query)
+          if result.nil? or result.ntuples == 0
+            return {}
+          else
+            data = []
+            # Build up a results set that is an array of arrays
+            # Each nested array is a set of 2 items: [value, limits state]
+            # If the item does not have limits the limits state is nil
+            result.each_with_index do |tuples, index|
+              data[index] ||= []
+              row_index = 0
+              tuples.each do |tuple|
+                if tuple[0].include?("__L")
+                  data[index][row_index - 1][1] = tuple[1]
+                elsif tuple[0] =~ /^__nil/
+                  data[index][row_index] = [nil, nil]
+                  row_index += 1
+                else
+                  data[index][row_index] = [tuple[1], nil]
+                  row_index += 1
+                end
+              end
+            end
+            # If we only have one row then we return a single array
+            if result.ntuples == 1
+              data = data[0]
+            end
+            return data
+          end
+        end
+      rescue IOError, PG::Error => e
+        # Retry the query because various errors can occur that are recoverable
+        retry_count += 1
+        if retry_count > 4
+          # After the 5th retry just raise the error
+          raise "Error querying QuestDB: #{e.message}"
+        end
+        Logger.warn("QuestDB: Retrying due to error: #{e.message}")
+        Logger.warn("QuestDB: Last query: #{query}") # Log the last query for debugging
+        @@conn_mutex.synchronize do
+          if @@conn and !@@conn.finished?
+            @@conn.finish()
+          end
+          @@conn = nil # Force the new connection
+        end
+        sleep 0.1
+        retry
+      end
+    end
+
     # Return all item values and limit state from the CVT
     #
     # @param items [Array<String>] Items to return. Must be formatted as TGT__PKT__ITEM__TYPE
     # @param stale_time [Integer] Time in seconds from Time.now that value will be marked stale
     # @return [Array] Array of values
-    def self.get_tlm_values(items, stale_time: 30, cache_timeout: nil, scope: $openc3_scope)
+    def self.get_tlm_values(items, stale_time: 30, cache_timeout: nil, start_time: nil, end_time: nil, scope: $openc3_scope)
       now = Time.now
       results = []
       lookups = []
       packet_lookup = {}
       overrides = {}
+
+      # If a start_time is passed we're doing a QuestDB lookup and directly return the results
+      # TODO: This currently does NOT support the override values
+      if start_time
+        return tsdb_lookup(items, start_time: start_time, end_time: end_time)
+      end
+
       # First generate a lookup hash of all the items represented so we can query the CVT
       items.each { |item| _parse_item(now, lookups, overrides, item, cache_timeout: cache_timeout, scope: scope) }
 
       now = now.to_f
       lookups.each do |target_packet_key, target_name, packet_name, value_keys|
+        if target_packet_key.nil?
+          results << [nil, nil]
+          next
+        end
         unless packet_lookup[target_packet_key]
           packet_lookup[target_packet_key] = get(target_name: target_name, packet_name: packet_name, cache_timeout: cache_timeout, scope: scope)
         end
@@ -161,7 +292,8 @@ module OpenC3
             if hash.key?(value_keys[-1])
               item_result[1] = nil
             else
-              raise "Item '#{target_name} #{packet_name} #{value_keys[-1]}' does not exist"
+              item_result[0] = nil
+              item_result[1] = nil
             end
           end
         end
@@ -335,6 +467,11 @@ module OpenC3
     # return an ordered array of hash with keys
     def self._parse_item(now, lookups, overrides, item, cache_timeout:, scope:)
       target_name, packet_name, item_name, value_type = item
+      # They will all be nil when item is a nil value
+      if item_name.nil?
+        lookups << nil
+        return
+      end
 
       # We build lookup keys by including all the less formatted types to gracefully degrade lookups
       # This allows the user to specify WITH_UNITS and if there is no conversions it will simply return the RAW value

data/lib/openc3/models/plugin_model.rb

@@ -55,6 +55,7 @@ module OpenC3
     attr_accessor :variables
     attr_accessor :plugin_txt_lines
     attr_accessor :needs_dependencies
+    attr_accessor :store_id
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -72,7 +73,7 @@ module OpenC3
 
     # Called by the PluginsController to parse the plugin variables
     # Doesn't actually create the plugin during the phase
-    def self.install_phase1(gem_file_path, existing_variables: nil, existing_plugin_txt_lines: nil, process_existing: false, scope:, validate_only: false)
+    def self.install_phase1(gem_file_path, existing_variables: nil, existing_plugin_txt_lines: nil, store_id: nil, process_existing: false, scope:, validate_only: false)
       gem_name = File.basename(gem_file_path).split("__")[0]
 
       temp_dir = Dir.mktmpdir
@@ -130,7 +131,8 @@ module OpenC3
           end
         end
 
-        model = PluginModel.new(name: gem_name, variables: variables, plugin_txt_lines: plugin_txt_lines, scope: scope)
+        store_id = Integer(store_id) if store_id
+        model = PluginModel.new(name: gem_name, variables: variables, plugin_txt_lines: plugin_txt_lines, store_id: store_id, scope: scope)
         result = model.as_json(:allow_nan => true)
         result['existing_plugin_txt_lines'] = existing_plugin_txt_lines if existing_plugin_txt_lines and not process_existing and existing_plugin_txt_lines != result['plugin_txt_lines']
         return result
@@ -299,6 +301,7 @@ module OpenC3
       variables: {},
       plugin_txt_lines: [],
       needs_dependencies: false,
+      store_id: nil,
       updated_at: nil,
       scope:
     )
@@ -306,6 +309,7 @@ module OpenC3
       @variables = variables
       @plugin_txt_lines = plugin_txt_lines
       @needs_dependencies = ConfigParser.handle_true_false(needs_dependencies)
+      @store_id = store_id
     end
 
     def create(update: false, force: false, queued: false)
@@ -319,6 +323,7 @@ module OpenC3
         'variables' => @variables,
         'plugin_txt_lines' => @plugin_txt_lines,
         'needs_dependencies' => @needs_dependencies,
+        'store_id' => @store_id,
         'updated_at' => @updated_at
       }
     end

data/lib/openc3/models/plugin_store_model.rb

@@ -0,0 +1,70 @@
+# encoding: ascii-8bit
+
+# Copyright 2025 OpenC3, Inc.
+# 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.
+
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/models/model'
+require 'openc3/utilities/store'
+
+module OpenC3
+  class PluginStoreModel < Model
+    PRIMARY_KEY = 'openc3_plugin_store'
+
+    def self.set(plugin_store_data)
+      Store.set(PRIMARY_KEY, plugin_store_data)
+    end
+
+    def self.all()
+      Store.get(PRIMARY_KEY)
+    end
+
+    def self.plugin_store_error(message)
+      Store.set(PRIMARY_KEY, [{
+        date: Time.now.utc.iso8601,
+        title: 'Plugin Store Error',
+        body: message,
+        error: true,
+      }].to_json)
+    end
+
+    def self.get_by_id(id)
+      plugins = JSON.parse(all()) rescue []
+      plugins.find { |plugin| plugin["id"] == Integer(id) }
+    end
+
+    def self.update
+      setting = SettingModel.get(name: 'store_url', scope: 'DEFAULT')
+      store_url = setting['data'] if setting
+      store_url = 'https://store.openc3.com' if store_url.nil? or store_url.strip.empty?
+      conn = Faraday.new(
+        url: store_url,
+      )
+      response = conn.get('/cosmos_plugins/json')
+      if response.success?
+        self.set(response.body)
+      else
+        self.plugin_store_error("Error contacting plugin store at #{store_url} (status: #{response.status})")
+      end
+    rescue Exception => e
+      self.plugin_store_error("Error contacting plugin store at #{store_url}. #{e.message})")
+    end
+
+    def self.ensure_exists
+      plugins = self.all()
+      self.update() if plugins.nil? or plugins.length.zero? or plugins[0]['error']
+    end
+  end
+end

data/lib/openc3/models/target_model.rb

@@ -1088,6 +1088,25 @@ module OpenC3
       Logger.info "Configured microservice #{microservice_name}"
     end
 
+    def deploy_tsdb_microservice(gem_path, variables, topics, instance = nil, parent = nil)
+      microservice_name = "#{@scope}__TSDB#{instance}__#{@name}"
+      microservice = MicroserviceModel.new(
+        name: microservice_name,
+        folder_name: @folder_name,
+        cmd: ["python", "quest_microservice.py", microservice_name],
+        work_dir: "/openc3/python/openc3/microservices",
+        topics: topics,
+        plugin: @plugin,
+        parent: nil,
+        needs_dependencies: @needs_dependencies,
+        shard: @shard,
+        scope: @scope
+      )
+      microservice.create
+      microservice.deploy(gem_path, variables)
+      Logger.info "Configured microservice #{microservice_name}"
+    end
+
     def deploy_reducer_microservice(gem_path, variables, topics, instance = nil, parent = nil)
       microservice_name = "#{@scope}__REDUCER#{instance}__#{@name}"
       microservice = MicroserviceModel.new(
@@ -1250,6 +1269,13 @@ module OpenC3
           deploy_decom_microservice(system.targets[@name], gem_path, variables, topics, instance, parent)
         end
 
+        # TSDB Microservice
+        if ENV['OPENC3_TSDB_HOSTNAME'] and ENV['OPENC3_TSDB_QUERY_PORT'] and ENV['OPENC3_TSDB_INGEST_PORT'] and ENV['OPENC3_TSDB_USERNAME'] and ENV['OPENC3_TSDB_PASSWORD']
+          deploy_target_microservices('TSDB', decom_topic_list, "#{@scope}__DECOM__{#{@name}}") do |topics, instance, parent|
+            deploy_tsdb_microservice(gem_path, variables, topics, instance, parent)
+          end
+        end
+
         # Reducer Microservice
         unless @reducer_disable
           # TODO: Does Reducer even need a topic list?

data/lib/openc3/models/tool_model.rb

@@ -184,7 +184,7 @@ module OpenC3
         end
       end
 
-      if @url and !@url.start_with?('/') and !@url.start_with?('http')
+      if @url and !@url.start_with?('/') and @url !~ URI::regexp
         raise "URL must be a full URL (http://domain.com/path) or a relative path (/path)"
       end
 

data/lib/openc3/packets/commands.rb

@@ -24,6 +24,7 @@
 # See https://github.com/OpenC3/cosmos/pull/1963
 
 require 'openc3/packets/packet_config'
+require 'openc3/utilities/cmd_log'
 
 module OpenC3
   # Commands uses PacketConfig to parse the command and telemetry
@@ -37,6 +38,7 @@ module OpenC3
   # Packet or PacketItem objects. While there are some overlapping methods between
   # the two, these are separate interfaces into the system.
   class Commands
+    include OpenC3::CmdLog
     attr_accessor :config
 
     LATEST_PACKET_NAME = 'LATEST'.freeze
@@ -203,60 +205,16 @@ module OpenC3
         raw = false
       end
       items.delete_if { |item_name, _item_value| ignored_parameters.include?(item_name) }
-      return build_cmd_output_string(packet.target_name, packet.packet_name, items, raw)
+      return build_cmd_output_string(packet.target_name, packet.packet_name, items, raw, packet)
     end
 
-    def build_cmd_output_string(target_name, cmd_name, cmd_params, raw = false)
-      if raw
-        output_string = 'cmd_raw("'
-      else
-        output_string = 'cmd("'
-      end
+    def build_cmd_output_string(target_name, cmd_name, cmd_params, raw = false, packet)
+      method_name = raw ? "cmd_raw" : "cmd"
       target_name = 'UNKNOWN' unless target_name
       cmd_name = 'UNKNOWN' unless cmd_name
-      output_string << (target_name + ' ' + cmd_name)
-      if cmd_params.nil? or cmd_params.empty?
-        output_string << '")'
-      else
-        begin
-          command_items = packet(target_name, cmd_name).items
-        rescue
-        end
-
-        params = []
-        cmd_params.each do |key, value|
-          next if Packet::RESERVED_ITEM_NAMES.include?(key)
-
-          begin
-            item_type = command_items[key].data_type
-          rescue
-            item_type = nil
-          end
+      packet_hash = packet ? packet.as_json : {}
 
-          if value.is_a?(String)
-            value = value.dup
-            if item_type == :BLOCK or item_type == :STRING
-              if !value.is_printable?
-                value = "0x" + value.simple_formatted
-              else
-                value = value.inspect
-              end
-            else
-              value = value.convert_to_value.to_s
-            end
-            if value.length > 256
-              value = value[0..255] + "...'"
-            end
-            value.tr!('"', "'")
-          elsif value.is_a?(Array)
-            value = "[#{value.join(", ")}]"
-          end
-          params << "#{key} #{value}"
-        end
-        params = params.join(", ")
-        output_string << (' with ' + params + '")')
-      end
-      return output_string
+      _build_cmd_output_string(method_name, target_name, cmd_name, cmd_params, packet_hash)
     end
 
     # Returns whether the given command is hazardous. Commands are hazardous

data/lib/openc3/packets/packet.rb

@@ -156,6 +156,7 @@ module OpenC3
         @virtual = false
         @restricted = false
         @validator = nil
+        @obfuscated_items = []
       end
 
       # Sets the target name this packet is associated with. Unidentified packets
@@ -333,7 +334,7 @@ module OpenC3
       synchronize() do
         begin
           internal_buffer_equals(buffer)
-        rescue RuntimeError => e
+        rescue RuntimeError
           Logger.instance.error "#{@target_name} #{@packet_name} received with actual packet length of #{buffer.length} but defined length of #{@defined_length}"
         end
         @read_conversion_cache.clear if @read_conversion_cache
@@ -556,6 +557,7 @@ module OpenC3
       item = super(item)
       update_id_items(item)
       update_limits_items_cache(item)
+      update_obfuscated_items_cache(item)
       item
     end
 
@@ -905,6 +907,7 @@ module OpenC3
       @short_buffer_allowed = false
       @id_items = nil
       @limits_items = nil
+      @obfuscated_items = []
       new_items = {}
       new_sorted_items = []
       @items.each do |name, item|
@@ -957,6 +960,21 @@ module OpenC3
       end
     end
 
+    # Add an item to the obfuscate items cache if necessary.
+    # You MUST call this after adding obfuscation to an item
+    # This is an optimization so we don't have to iterate through all the items when
+    # checking for obfuscation.
+    def update_obfuscated_items_cache(item)
+      if item.obfuscate
+        @obfuscated_items ||= []
+        @obfuscated_items_hash ||= {}
+        unless @obfuscated_items_hash[item]
+          @obfuscated_items << item
+          @obfuscated_items_hash[item] = true
+        end
+      end
+    end
+
     # Return an array of arrays indicating all items in the packet that are out of limits
     #   [[target name, packet name, item name, item limits state], ...]
     #
@@ -1158,6 +1176,7 @@ module OpenC3
       config['validator'] = @validator.class.to_s if @validator
       config['template'] = Base64.encode64(@template) if @template
       config['config_name'] = self.config_name
+      config['obfuscated_items'] = @obfuscated_items&.map(&:name) || []
 
       if @processors
         processors = []
@@ -1287,6 +1306,52 @@ module OpenC3
       end
     end
 
+    def obfuscate()
+      return unless @buffer
+      return unless @obfuscated_items
+
+      @obfuscated_items.each do |item|
+        next if item.data_type == :DERIVED
+
+        begin
+          current_value = read(item.name, :RAW)
+
+          case current_value
+          when Array
+            # For arrays, create a new array of zeros with the same size
+            case item.data_type
+              when :INT, :UINT
+                obfuscated_value = Array.new(current_value.size, 0)
+              when :FLOAT
+                obfuscated_value = Array.new(current_value.size, 0.0)
+              when :STRING, :BLOCK
+                obfuscated_value = Array.new(current_value.size) { |i|
+                  "\x00" * current_value[i].length if current_value[i]
+                }
+            else
+              obfuscated_value = Array.new(current_value.size, 0)
+            end
+          when String
+            # For strings/blocks, create null bytes of the same length
+            obfuscated_value = "\x00" * current_value.length
+          else
+            case item.data_type
+            when :INT, :UINT
+              obfuscated_value = 0
+            when :FLOAT
+              obfuscated_value = 0.0
+            else
+              obfuscated_value = 0
+            end
+          end
+          write(item.name, obfuscated_value, :RAW)
+        rescue => e
+          Logger.instance.error "#{item.name} obfuscation failed with error: #{e.message}"
+          next
+        end
+      end
+    end
+
     protected
 
     def handle_limits_states(item, value)
@@ -1404,4 +1469,4 @@ module OpenC3
       item
     end
   end
-end
+end

data/lib/openc3/packets/packet_config.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2024, OpenC3, Inc.
+# All changes Copyright 2025, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -234,7 +234,8 @@ module OpenC3
               'POLY_WRITE_CONVERSION', 'SEG_POLY_READ_CONVERSION', 'SEG_POLY_WRITE_CONVERSION',\
               'GENERIC_READ_CONVERSION_START', 'GENERIC_WRITE_CONVERSION_START', 'REQUIRED',\
               'LIMITS', 'LIMITS_RESPONSE', 'UNITS', 'FORMAT_STRING', 'DESCRIPTION',\
-              'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP', 'KEY', 'VARIABLE_BIT_SIZE'
+              'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE', 'OVERFLOW', 'OVERLAP', 'KEY', 'VARIABLE_BIT_SIZE',\
+              'OBFUSCATE'
             raise parser.error("No current item for #{keyword}") unless @current_item
 
             process_current_item(parser, keyword, params)
@@ -692,6 +693,13 @@ module OpenC3
         @current_item.units_full = params[0]
         @current_item.units = params[1]
 
+      # Obfuscate the parameter in logs
+      when 'OBFUSCATE'
+        usage = "OBFUSCATE"
+        parser.verify_num_parameters(0, 0, usage)
+        @current_item.obfuscate = true
+        @current_packet.update_obfuscated_items_cache(@current_item)
+
       # Update the description for the current telemetry item
       when 'DESCRIPTION'
         usage = "DESCRIPTION <DESCRIPTION>"

data/lib/openc3/packets/packet_item.rb

@@ -14,7 +14,7 @@
 # GNU Affero General Public License for more details.
 
 # Modified by OpenC3, Inc.
-# All changes Copyright 2022, OpenC3, Inc.
+# All changes Copyright 2025, OpenC3, Inc.
 # All Rights Reserved
 #
 # This file may also be used under the terms of a commercial license
@@ -93,6 +93,9 @@ module OpenC3
     # @return [PacketItemLimits] All information regarding limits for this PacketItem
     attr_reader :limits
 
+    # @return [Boolean] Whether the parameter must be obfuscated from logs or not
+    attr_accessor :obfuscate
+
     # (see StructureItem#initialize)
     # It also initializes the attributes of the PacketItem.
     def initialize(name, bit_offset, bit_size, data_type, endianness, array_size = nil, overflow = :ERROR)
@@ -109,6 +112,7 @@ module OpenC3
       @range = nil
       @required = false
       @hazardous = nil
+      @obfuscate = false
       @messages_disabled = nil
       @state_colors = nil
       @limits = PacketItemLimits.new
@@ -314,6 +318,7 @@ module OpenC3
       item.state_colors = self.state_colors.clone if self.state_colors
       item.limits = self.limits.clone if self.limits
       item.meta = self.meta.clone if @meta
+      item.obfuscate = self.obfuscate.clone if @obfuscate
       item
     end
     alias dup clone
@@ -345,6 +350,7 @@ module OpenC3
       hash['limits'] = self.limits.to_hash
       hash['meta'] = nil
       hash['meta'] = @meta if @meta
+      hash['obfuscate'] = self.obfuscate
       hash
     end
 
@@ -404,6 +410,7 @@ module OpenC3
       config << "    FORMAT_STRING #{self.format_string.to_s.quote_if_necessary}\n" if self.format_string
       config << "    UNITS #{self.units_full.to_s.quote_if_necessary} #{self.units.to_s.quote_if_necessary}\n" if self.units
       config << "    OVERFLOW #{self.overflow}\n" if self.overflow != :ERROR
+      config << "    OBFUSCATE\n" if self.obfuscate
 
       if @states
         @states.each do |state_name, state_value|
@@ -512,6 +519,7 @@ module OpenC3
 
       config['meta'] = @meta if @meta
       config['variable_bit_size'] = @variable_bit_size if @variable_bit_size
+      config['obfuscate'] = self.obfuscate
       config
     end
 
@@ -573,6 +581,7 @@ module OpenC3
         item.limits.values = values if values.length > 0
       end
       item.meta = hash['meta']
+      item.obfuscate = hash['obfuscate']
       item.variable_bit_size = hash['variable_bit_size']
       item
     end

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

@@ -80,7 +80,13 @@ module OpenC3
       if data_type == :STRING || data_type == :BLOCK
         @parser.parameters[1]
       else
-        @parser.parameters[1].convert_to_value
+        value = @parser.parameters[1].convert_to_value
+        # Check if the value is a string, which indicates an error in parsing
+        # except for 'ANY' which is a valid state value
+        if value.is_a?(String) and value != "ANY"
+          raise @parser.error("Invalid state value #{value} for data type #{data_type}.", @usage)
+        end
+        return value
       end
     end