openc3 5.0.6

data/lib/openc3/interfaces/serial_interface.rb

@@ -0,0 +1,94 @@
+# 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/interfaces/stream_interface'
+require 'openc3/streams/serial_stream'
+
+module OpenC3
+  # Provides a base class for interfaces that use serial ports
+  class SerialInterface < StreamInterface
+    # Creates a serial interface which uses the specified stream protocol.
+    #
+    # @param write_port_name [String] The name of the serial port to write
+    # @param read_port_name [String] The name of the serial port to read
+    # @param baud_rate [Integer] The serial port baud rate
+    # @param parity [Symbol] The parity which is normally :NONE.
+    #   Must be one of :NONE, :EVEN, or :ODD.
+    # @param stop_bits [Integer] The number of stop bits which is normally 1.
+    # @param write_timeout [Integer] The number of seconds to attempt the write
+    #   before aborting
+    # @param read_timeout [Integer] The number of seconds to attempt to read
+    #   data from the serial port before aborting
+    # @param protocol_type [String] Combined with 'Protocol' to resolve
+    #   to a OpenC3 protocol class
+    # @param protocol_args [Array] Arguments to pass to the protocol constructor
+    def initialize(write_port_name,
+                   read_port_name,
+                   baud_rate,
+                   parity,
+                   stop_bits,
+                   write_timeout,
+                   read_timeout,
+                   protocol_type = nil,
+                   *protocol_args)
+      super(protocol_type, protocol_args)
+
+      @write_port_name = ConfigParser.handle_nil(write_port_name)
+      @read_port_name = ConfigParser.handle_nil(read_port_name)
+      @baud_rate = baud_rate
+      @parity = parity.to_s.intern
+      @stop_bits = stop_bits
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+      @write_allowed = false unless @write_port_name
+      @write_raw_allowed = false unless @write_port_name
+      @read_allowed = false unless @read_port_name
+      @flow_control = :NONE
+      @data_bits = 8
+    end
+
+    # Creates a new {SerialStream} using the parameters passed in the constructor
+    def connect
+      @stream = SerialStream.new(
+        @write_port_name,
+        @read_port_name,
+        @baud_rate,
+        @parity,
+        @stop_bits,
+        @write_timeout,
+        @read_timeout,
+        @flow_control,
+        @data_bits
+      )
+      super()
+    end
+
+    # Supported Options
+    # FLOW_CONTROL - Flow control method NONE or RTSCTS. Defaults to NONE
+    def set_option(option_name, option_values)
+      super(option_name, option_values)
+      case option_name.upcase
+      when 'FLOW_CONTROL'
+        @flow_control = option_values[0]
+      when 'DATA_BITS'
+        @data_bits = option_values[0].to_i
+      end
+    end
+  end
+end

data/lib/openc3/interfaces/simulated_target_interface.rb

@@ -0,0 +1,168 @@
+# 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/interfaces/interface'
+require 'openc3/interfaces/protocols/override_protocol'
+
+module OpenC3
+  # An interface class that provides simulated telemetry and command responses
+  class SimulatedTargetInterface < Interface
+    # @param sim_target_file [String] Filename of the simulator target class
+    def initialize(sim_target_file)
+      super()
+      @connected = false
+      @initialized = false
+      @count_100hz = 0
+      @next_tick_time = nil
+      @pending_packets = []
+      @sim_target_class = OpenC3.require_class sim_target_file
+      @sim_target = nil
+      @write_raw_allowed = false
+      @raw_logger_pair = nil
+      add_protocol(OverrideProtocol, [], :READ)
+    end
+
+    # Initialize the simulated target object and "connect" to the target
+    def connect
+      unless @initialized
+        # Create Simulated Target Object
+        @sim_target = @sim_target_class.new(@target_names[0])
+        # Set telemetry rates
+        @sim_target.set_rates
+
+        @initialized = true
+      end
+
+      @count_100hz = 0
+
+      # Save the current time + delta as the next expected tick time
+      @next_tick_time = Time.now.sys + @sim_target.tick_period_seconds
+
+      @connected = true
+    end
+
+    # @return [Boolean] Whether the simulated target is connected (initialized)
+    def connected?
+      @connected
+    end
+
+    # @return [Packet] Returns a simulated target packet from the simulator
+    def read
+      packet = nil
+      if @connected
+        packet = first_pending_packet()
+        if packet
+          # Support read_packet (but not read data) in protocols
+          # Generic protocol use is not supported
+          @read_protocols.each do |protocol|
+            packet = protocol.read_packet(packet)
+            if packet == :DISCONNECT
+              Logger.info("#{@name}: Protocol #{protocol.class} read_packet requested disconnect")
+              return nil
+            end
+            break if packet == :STOP
+          end
+          return packet unless packet == :STOP
+        end
+
+        while true
+          # Calculate time to sleep to make ticks the right distance apart
+          now = Time.now.sys
+          delta = @next_tick_time - now
+          if delta > 0.0
+            sleep(delta) # Sleep between packets
+            return nil unless @connected
+          elsif delta < -1.0
+            # Fell way behind - jump next tick time
+            @next_tick_time = Time.now.sys
+          end
+
+          @pending_packets = @sim_target.read(@count_100hz, @next_tick_time)
+          @next_tick_time += @sim_target.tick_period_seconds
+          @count_100hz += @sim_target.tick_increment
+
+          packet = first_pending_packet()
+          if packet
+            # Support read_packet (but not read data) in protocols
+            # Generic protocol use is not supported
+            @read_protocols.each do |protocol|
+              packet = protocol.read_packet(packet)
+              if packet == :DISCONNECT
+                Logger.info("#{@name}: Protocol #{protocol.class} read_packet requested disconnect")
+                return nil
+              end
+              break if packet == :STOP
+            end
+            next if packet == :STOP
+
+            return packet
+          end
+        end
+      else
+        raise "Interface not connected"
+      end
+      return packet
+    end
+
+    # @param packet [Packet] Command packet to send to the simulator
+    def write(packet)
+      if @connected
+        # Update count of commands sent through this interface
+        @write_count += 1
+        @bytes_written += packet.length
+        @written_raw_data_time = Time.now
+        @written_raw_data = packet.buffer
+
+        # Have simulated target handle the packet
+        @sim_target.write(packet)
+      else
+        raise "Interface not connected"
+      end
+    end
+
+    # write_raw is not implemented and will raise a RuntimeError
+    def write_raw(data)
+      raise "write_raw not implemented for SimulatedTargetInterface"
+    end
+
+    # Raise an error because raw logging is not supported for this interface
+    def raw_logger_pair=(raw_logger_pair)
+      raise "Raw logging not supported for SimulatedTargetInterface"
+    end
+
+    # Disconnect from the simulator
+    def disconnect
+      @connected = false
+    end
+
+    protected
+
+    def first_pending_packet
+      packet = nil
+      unless @pending_packets.empty?
+        @read_count += 1
+        packet = @pending_packets.pop.clone
+        @bytes_read += packet.length
+        @read_raw_data_time = Time.now
+        @read_raw_data = packet.buffer
+      end
+      packet
+    end
+  end
+end

data/lib/openc3/interfaces/stream_interface.rb

@@ -0,0 +1,81 @@
+# 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/interfaces/interface'
+
+module OpenC3
+  # Base class for interfaces that act read and write from a stream
+  class StreamInterface < Interface
+    attr_accessor :stream
+
+    def initialize(protocol_type = nil, protocol_args = [])
+      super()
+      @stream = nil
+      @protocol_type = ConfigParser.handle_nil(protocol_type)
+      @protocol_args = protocol_args
+      if @protocol_type
+        protocol_class_name = protocol_type.to_s.capitalize << 'Protocol'
+        klass = OpenC3.require_class(protocol_class_name.class_name_to_filename)
+        add_protocol(klass, protocol_args, :READ_WRITE)
+      end
+    end
+
+    def connect
+      super()
+      @stream.connect if @stream
+    end
+
+    def connected?
+      if @stream
+        @stream.connected?
+      else
+        false
+      end
+    end
+
+    def disconnect
+      @stream.disconnect if @stream
+      super()
+    end
+
+    def read_interface
+      timeout = false
+      begin
+        data = @stream.read
+      rescue Timeout::Error
+        Logger.error "#{@name}: Timeout waiting for data to be read"
+        timeout = true
+        data = nil
+      end
+      if data.nil? or data.length <= 0
+        Logger.info "#{@name}: #{@stream.class} read returned nil" if data.nil? and not timeout
+        Logger.info "#{@name}: #{@stream.class} read returned 0 bytes (stream closed)" if not data.nil? and data.length <= 0
+        return nil
+      end
+
+      read_interface_base(data)
+      data
+    end
+
+    def write_interface(data)
+      write_interface_base(data)
+      @stream.write(data)
+    end
+  end
+end

data/lib/openc3/interfaces/tcpip_client_interface.rb

@@ -0,0 +1,69 @@
+# 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/interfaces/stream_interface'
+require 'openc3/streams/tcpip_client_stream'
+
+module OpenC3
+  # Base class for interfaces that act as a TCP/IP client
+  class TcpipClientInterface < StreamInterface
+    # @param hostname [String] Machine to connect to
+    # @param write_port [Integer] Port to write commands to
+    # @param read_port [Integer] Port to read telemetry from
+    # @param write_timeout [Integer] Seconds to wait before aborting writes
+    # @param read_timeout [Integer] Seconds to wait before aborting reads
+    # @param protocol_type [String] Name of the protocol to use
+    #   with this interface
+    # @param protocol_args [Array<String>] Arguments to pass to the protocol
+    def initialize(
+      hostname,
+      write_port,
+      read_port,
+      write_timeout,
+      read_timeout,
+      protocol_type = nil,
+      *protocol_args
+    )
+
+      super(protocol_type, protocol_args)
+
+      @hostname = hostname
+      @write_port = ConfigParser.handle_nil(write_port)
+      @read_port = ConfigParser.handle_nil(read_port)
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+      @read_allowed = false unless @read_port
+      @write_allowed = false unless @write_port
+      @write_raw_allowed = false unless @write_port
+    end
+
+    # Connects the {TcpipClientStream} by passing the
+    # initialization parameters to the {TcpipClientStream}.
+    def connect
+      @stream = TcpipClientStream.new(
+        @hostname,
+        @write_port,
+        @read_port,
+        @write_timeout,
+        @read_timeout
+      )
+      super()
+    end
+  end
+end