Class: OpenC3::CommandDecomTopic

Inherits:
Topic show all
Defined in:
lib/openc3/topics/command_decom_topic.rb

Class Method Summary collapse

Methods inherited from Topic

all_same_db_shard?, clear_topics, del, get_cnt, get_last_offset, get_newest_message, get_oldest_message, group_topics_by_db_shard, method_missing, read_topics, trim_topic, update_topic_offsets, write_ack, write_topic

Class Method Details

.get_cmd_item(target_name, packet_name, param_name, type: :FORMATTED, scope: $openc3_scope) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/openc3/topics/command_decom_topic.rb', line 49

def self.get_cmd_item(target_name, packet_name, param_name, type: :FORMATTED, scope: $openc3_scope)
  db_shard = Store.db_shard_for_target(target_name, scope: scope)
  msg_id, msg_hash = Topic.get_newest_message("#{scope}__DECOMCMD__{#{target_name}}__#{packet_name}", db_shard: db_shard)
  if msg_id
    if param_name == 'RECEIVED_COUNT'
      msg_hash['received_count'].to_i
    else
      json = msg_hash['json_data']
      hash = JSON.parse(json, allow_nan: true, create_additions: true)
      # Start from the most complex down to the basic raw value
      value = hash["#{param_name}__F"]
      return value if value && (type == :WITH_UNITS || type == :FORMATTED)

      value = hash["#{param_name}__C"]
      return value if value && (type == :WITH_UNITS || type == :FORMATTED || type == :CONVERTED)

      return hash[param_name]
    end
  end
end

.write_packet(packet, scope:) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/openc3/topics/command_decom_topic.rb', line 23

def self.write_packet(packet, scope:)
  topic = "#{scope}__DECOMCMD__{#{packet.target_name}}__#{packet.packet_name}"
  msg_hash = { time: packet.packet_time.to_nsec_from_epoch,
               received_time: packet.received_time.to_nsec_from_epoch,
               target_name: packet.target_name,
               packet_name: packet.packet_name,
               stored: packet.stored.to_s,
               received_count: packet.received_count }
  # Read all RAW values at once - optimized by accessor
  json_hash = packet.read_items(packet.sorted_items)
  # Read additional value types using given_raw to avoid re-reading from buffer
  packet.sorted_items.each do |item|
    if item.hidden
      json_hash.delete(item.name)
    else
      given_raw = json_hash[item.name]
      json_hash[item.name + "__C"] = packet.read_item(item, :CONVERTED, packet.buffer, given_raw) if item.write_conversion or item.states
      json_hash[item.name + "__F"] = packet.read_item(item, :FORMATTED, packet.buffer, given_raw) if item.format_string
    end
  end
  msg_hash['json_data'] = JSON.generate(json_hash.as_json, allow_nan: true)
  msg_hash['extra'] = JSON.generate(packet.extra.as_json, allow_nan: true) if packet.extra
  db_shard = Store.db_shard_for_target(packet.target_name, scope: scope)
  EphemeralStoreQueued.instance(db_shard: db_shard).write_topic(topic, msg_hash)
end