openc3 5.0.6

data/lib/openc3/tools/table_manager/table.rb

@@ -0,0 +1,77 @@
+# 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/packet'
+require 'openc3/tools/table_manager/table_item'
+
+module OpenC3
+  # Table extends Packet by adding more attributes relative to
+  # displaying binary data in a gui.
+  class Table < Packet
+    # Define the target for tables as 'TABLE' since there is no target
+    TARGET = 'TABLE'
+
+    # @return [Symbol] Either :KEY_VALUE or :ROW_COLUMN
+    attr_reader :type
+
+    # @return [String] File which contains the table definition
+    attr_reader :filename
+
+    # @return [Integer] Number of columns in the table
+    attr_accessor :num_columns
+
+    alias table_name packet_name
+
+    # Constructor for a TableDefinition
+    def initialize(name, endianness, type, description, filename)
+      super(TARGET, name, endianness, description, '', TableItem)
+      # ONE_DIMENSIONAL and TWO_DIMENSIONAL are deprecated so translate
+      type = :KEY_VALUE if type == :ONE_DIMENSIONAL
+      type = :ROW_COLUMN if type == :TWO_DIMENSIONAL
+      if type != :KEY_VALUE && type != :ROW_COLUMN
+        raise ArgumentError,
+              "Invalid type '#{type}' for table '#{name}'. Must be KEY_VALUE or ROW_COLUMN"
+      end
+      @type = type
+      @filename = filename
+      @num_rows = 0
+      @num_columns = (@type == :KEY_VALUE) ? 1 : 0
+    end
+
+    # @param num_rows [Integer] Set the number of rows in a ROW_COLUMN table
+    def num_rows=(num_rows)
+      case @type
+      when :KEY_VALUE
+        raise 'Rows are fixed in a KEY_VALUE table'
+      when :ROW_COLUMN
+        @num_rows = num_rows
+      end
+    end
+
+    # @return [Integer] Number of rows in the table
+    def num_rows
+      case @type
+      when :KEY_VALUE
+        @sorted_items.count { |item| !item.hidden }
+      when :ROW_COLUMN
+        @num_rows
+      end
+    end
+  end
+end

data/lib/openc3/tools/table_manager/table_config.rb

@@ -0,0 +1,273 @@
+# 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/config/config_parser'
+require 'openc3/packets/packet_config'
+require 'openc3/tools/table_manager/table'
+require 'openc3/tools/table_manager/table_parser'
+require 'openc3/tools/table_manager/table_item_parser'
+
+module OpenC3
+  # Processes the Table Manager configuration files which define tables. Since
+  # this class inherits from {PacketConfig} it only needs to implement Table
+  # Manager specific keywords. All tables are accessed through the table
+  # and tables methods.
+  class TableConfig < PacketConfig
+    # @return [String] Table configuration filename
+    attr_reader :filename
+
+    def self.process_file(filename)
+      instance = self.new()
+      instance.process_file(filename)
+      instance
+    end
+
+    # Create the table configuration
+    def initialize
+      super
+      # Override commands with the Table::TARGET name to store tables
+      @commands[Table::TARGET] = {}
+      @definitions = {}
+      @last_config = [] # Stores array of [filename, contents]
+    end
+
+    # @return [Array<Table>] All tables defined in the configuration file
+    def tables
+      @commands[Table::TARGET]
+    end
+
+    # @return [String] Table definition for the specific table
+    def definition(table_name)
+      @definitions[table_name.upcase]
+    end
+
+    # @return [Array<String>] All the table names
+    def table_names
+      tables.keys
+    end
+
+    # @param table_name [String] Table name to return
+    # @return [Table]
+    def table(table_name)
+      tables[table_name.upcase]
+    end
+
+    # Processes a OpenC3 table configuration file and uses the keywords to build up
+    # knowledge of the tables.
+    #
+    # @param filename [String] The name of the configuration file
+    def process_file(filename)
+      # Partial files are included into another file and thus aren't directly processed
+      return if File.basename(filename)[0] == '_' # Partials start with underscore
+      @filename = filename
+      @last_config = [File.basename(filename), File.read(filename)]
+      @converted_type = nil
+      @converted_bit_size = nil
+      @proc_text = ''
+      @building_generic_conversion = false
+      @defaults = []
+
+      parser =
+        ConfigParser.new(
+          'https://openc3.com/docs/tools/#table-manager-configuration-openc3--39',
+        )
+      parser.parse_file(filename) do |keyword, params|
+        if @building_generic_conversion
+          case keyword
+          # Complete a generic conversion
+          when 'GENERIC_READ_CONVERSION_END', 'GENERIC_WRITE_CONVERSION_END'
+            parser.verify_num_parameters(0, 0, keyword)
+            @current_item.read_conversion =
+              GenericConversion.new(
+                @proc_text,
+                @converted_type,
+                @converted_bit_size,
+              ) if keyword.include? 'READ'
+            @current_item.write_conversion =
+              GenericConversion.new(
+                @proc_text,
+                @converted_type,
+                @converted_bit_size,
+              ) if keyword.include? 'WRITE'
+            @building_generic_conversion = false
+            # Add the current config.line to the conversion being built
+          else
+            @proc_text << parser.line << "\n"
+          end # case keyword
+        else
+          # not building generic conversion
+          case keyword
+          when 'TABLEFILE'
+            usage = "#{keyword} <File name>"
+            parser.verify_num_parameters(1, 1, usage)
+            table_filename = File.join(File.dirname(filename), params[0])
+            unless File.exist?(table_filename)
+              raise parser.error(
+                      "Table file #{table_filename} not found",
+                      usage,
+                    )
+            end
+            process_file(table_filename)
+
+          when 'TABLE'
+            finish_packet
+            @current_packet =
+              TableParser.parse_table(parser, @commands, @warnings)
+            @definitions[@current_packet.packet_name] = @last_config
+            @current_cmd_or_tlm = COMMAND
+            @default_index = 0
+
+            # Select an existing table for editing
+          when 'SELECT_TABLE'
+            usage = "#{keyword} <TABLE NAME>"
+            finish_packet
+            parser.verify_num_parameters(1, 1, usage)
+            table_name = params[0].upcase
+            @current_packet = table(table_name)
+            unless @current_packet
+              raise parser.error("Table #{table_name} not found", usage)
+            end
+
+            #######################################################################
+            # All the following keywords must have a current packet defined
+            #######################################################################
+          when 'SELECT_PARAMETER', 'PARAMETER', 'ID_PARAMETER',
+               'ARRAY_PARAMETER', 'APPEND_PARAMETER', 'APPEND_ID_PARAMETER',
+               'APPEND_ARRAY_PARAMETER', 'ALLOW_SHORT', 'HAZARDOUS',
+               'PROCESSOR', 'META', 'DISABLE_MESSAGES', 'DISABLED'
+            unless @current_packet
+              raise parser.error("No current packet for #{keyword}")
+            end
+            process_current_packet(parser, keyword, params)
+
+            #######################################################################
+            # All the following keywords must have a current item defined
+            #######################################################################
+          when 'STATE', 'READ_CONVERSION', 'WRITE_CONVERSION',
+               'POLY_READ_CONVERSION', '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',
+               'HIDDEN', 'MINIMUM_VALUE', 'MAXIMUM_VALUE', 'DEFAULT_VALUE',
+               'OVERFLOW', 'UNEDITABLE'
+            unless @current_item
+              raise parser.error("No current item for #{keyword}")
+            end
+            process_current_item(parser, keyword, params)
+
+          when 'DEFAULT'
+            if params.length != @current_packet.sorted_items.length
+              raise parser.error("DEFAULT #{params.join(' ')} length of #{params.length} doesn't match item length of #{@current_packet.sorted_items.length}")
+            end
+            @defaults.concat(params)
+
+          else
+            # blank config.lines will have a nil keyword and should not raise an exception
+            raise parser.error("Unknown keyword '#{keyword}'") if keyword
+          end # case keyword
+        end
+      end
+
+      # Complete the last defined packet
+      finish_packet
+    end
+
+    # (see PacketConfig#process_current_packet)
+    def process_current_packet(parser, keyword, params)
+      super(parser, keyword, params)
+    rescue => err
+      if err.message.include?('not found')
+        raise parser.error(
+                "#{params[0]} not found in table #{@current_packet.table_name}",
+                'SELECT_PARAMETER <PARAMETER NAME>',
+              )
+      else
+        raise err
+      end
+    end
+
+    # Overridden method to handle the unique table item parameters: UNEDITABLE
+    # and HIDDEN.
+    # (see PacketConfig#process_current_item)
+    def process_current_item(parser, keyword, params)
+      super(parser, keyword, params)
+      case keyword
+      when 'UNEDITABLE'
+        usage = "#{keyword}"
+        parser.verify_num_parameters(0, 0, usage)
+        @current_item.editable = false
+      when 'HIDDEN'
+        usage = "#{keyword}"
+        parser.verify_num_parameters(0, 0, usage)
+        @current_item.hidden = true
+      end
+    end
+
+    # (see PacketConfig#start_item)
+    def start_item(parser)
+      finish_item
+      @current_item = TableItemParser.parse(parser, @current_packet, @warnings)
+    end
+
+    # If the table is ROW_COLUMN all currently defined items are
+    # duplicated until the specified number of rows are created.
+    def finish_packet
+      if @current_packet
+        warnings = @current_packet.check_bit_offsets
+        if warnings.length > 0
+          raise "Overlapping items not allowed in tables.\n#{warnings}"
+        end
+        if @current_packet.type == :ROW_COLUMN
+          items = @current_packet.sorted_items.clone
+          (@current_packet.num_rows - 1).times do |row|
+            items.each do |item|
+              new_item = item.clone
+              new_item.name = "#{new_item.name[0...-1]}#{row + 1}"
+              @current_packet.append(new_item)
+            end
+          end
+        end
+        unless @defaults.empty?
+          @current_packet.sorted_items.each_with_index do |item, index|
+            case item.data_type
+            when :INT, :UINT
+              begin
+                # Integer handles hex strings, e.g. 0xDEADBEEF
+                item.default = Integer(@defaults[index])
+              rescue ArgumentError
+                value = item.states[@defaults[index]]
+                if value
+                  item.default = value
+                else
+                  raise "Unknown DEFAULT #{@defaults[index]} for item #{item.name}. Valid states are #{item.states.keys.join(', ')}."
+                end
+              end
+            when :FLOAT
+              item.default = @defaults[index].to_f
+            when :STRING, :BLOCK
+              item.default = @defaults[index]
+            end
+          end
+        end
+      end
+      super()
+    end
+  end
+end

data/lib/openc3/tools/table_manager/table_item.rb

@@ -0,0 +1,90 @@
+# 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/packet_item'
+
+module OpenC3
+  # Implements the attributes that are unique to a TableItem such as editable
+  # and hidden. All other functionality is inherited from {PacketItem}.
+  class TableItem < PacketItem
+    # @return [Boolean] Whether this item is editable
+    attr_reader :editable
+
+    # @return [Boolean] Whether this item is hidden (not displayed)
+    attr_reader :hidden
+
+    # (see PacketItem#initialize)
+    def initialize(
+      name,
+      bit_offset,
+      bit_size,
+      data_type,
+      endianness,
+      array_size = nil,
+      overflow = :ERROR
+    )
+      super(
+        name,
+        bit_offset,
+        bit_size,
+        data_type,
+        endianness,
+        array_size,
+        overflow,
+      )
+      @display_type = nil
+      @editable = true
+      @hidden = false
+    end
+
+    # @param editable [Boolean] Whether this item can be edited
+    def editable=(editable)
+      unless !!editable == editable
+        raise ArgumentError,
+              "#{@name}: editable must be a boolean but is a #{editable.class}"
+      end
+      @editable = editable
+    end
+
+    # @param hidden [Boolean] Whether this item should be hidden
+    def hidden=(hidden)
+      unless !!hidden == hidden
+        raise ArgumentError,
+              "#{@name}: hidden must be a boolean but is a #{hidden.class}"
+      end
+      @hidden = hidden
+    end
+
+    # Make a light weight clone of this item
+    def clone
+      item = super()
+      item.editable = self.editable
+      item
+    end
+    alias dup clone
+
+    # Create a hash of this item's attributes
+    def as_json(*a)
+      hash = super()
+      hash['editable'] = self.editable
+      hash['hidden'] = self.hidden
+      hash
+    end
+  end
+end

data/lib/openc3/tools/table_manager/table_item_parser.rb

@@ -0,0 +1,66 @@
+# 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/packet_config'
+require 'openc3/packets/parsers/packet_item_parser'
+require 'openc3/tools/table_manager/table_item'
+
+module OpenC3
+  # Extends the PacketItemParser to create TableItems for TableManager
+  class TableItemParser < PacketItemParser
+    # @param parser [ConfigParser] Configuration parser
+    # @param table [Table] Table all parsed items should be added to
+    # # @param warnings [Array<String>] Array of warning strings from PacketConfig
+    def self.parse(parser, table, warnings)
+      parser = TableItemParser.new(parser, warnings)
+      parser.verify_parameters(PacketConfig::COMMAND)
+      parser.create_table_item(table)
+    end
+
+    # @param table [Table] Table created items are added to
+    def create_table_item(table)
+      name = @parser.parameters[0]
+      if table.type == :ROW_COLUMN
+        name = "#{name}0"
+        table.num_columns += 1
+      end
+      item =
+        TableItem.new(
+          name,
+          get_bit_offset,
+          get_bit_size,
+          get_data_type,
+          get_endianness(table),
+          get_array_size,
+          :ERROR,
+        ) # overflow
+      item.range = get_range
+      item.default = get_default
+      item.description = get_description
+      if append?
+        item = table.append(item)
+      else
+        item = table.define(item)
+      end
+      item
+    rescue => err
+      raise @parser.error(err, @usage)
+    end
+  end
+end