cosmos 4.0.3-java

data/lib/cosmos/packet_logs/packet_log_writer.rb

@@ -0,0 +1,341 @@
+# 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 'thread'
+require 'socket' # For gethostname
+require 'cosmos/config/config_parser'
+require 'cosmos/packet_logs/packet_log_reader'
+
+module Cosmos
+
+  # Creates a packet log of either commands or telemetry. Can automatically
+  # cycle the log based on an elasped time period or when the log file reaches
+  # a predefined size.
+  class PacketLogWriter
+
+    # @return [String] The filename of the packet log
+    attr_reader :filename
+
+    # @return [true/false] Whether logging is enabled
+    attr_reader :logging_enabled
+
+    # @return [Queue] Queue for asynchronous logging
+    attr_reader :queue
+
+    # The allowable log types
+    LOG_TYPES = [:CMD, :TLM]
+
+    # The cycle time interval. Cycle times are only checked at this level of
+    # granularity.
+    CYCLE_TIME_INTERVAL = 2
+
+    # @param log_type [Symbol] The type of packet log to create. Must be :CMD
+    #   or :TLM.
+    # @param log_name [String|nil] Identifier to put in the log file name. This
+    #   will be prepended with a date / time stamp and appended by the
+    #   log_type. Thus passing 'test' for a :CMD log will result in a filename
+    #   of 'YYYY_MM_DD_HH_MM_SS_testcmd.bin'. Pass nil to ignore this
+    #   parameter.
+    # @param logging_enabled [Boolean] Whether to start with logging enabled
+    # @param cycle_time [Integer] The amount of time in seconds before creating
+    #   a new log file. This can be combined with cycle_size but is better used
+    #   independently.
+    # @param cycle_size [Integer] The size in bytes before creating a new log
+    #   file. This can be combined with cycle_time but is better used
+    #   independently.
+    # @param log_directory [String] The directory to store the log files.
+    #   Passing nil will use the system default 'LOGS' directory.
+    # @param asynchronous [Boolean] Whether to spawn a new thread to write
+    #   packets to the log rather than writing the packets in the current
+    #   thread context.  Note that this is (alot) slower overall but may reduce
+    #   interface receive latency
+    def initialize(
+      log_type,
+      log_name = nil,
+      logging_enabled = true,
+      cycle_time = nil,
+      cycle_size = 2000000000,
+      log_directory = nil,
+      asynchronous = false
+    )
+      raise "log_type must be :CMD or :TLM" unless LOG_TYPES.include? log_type
+      @log_type = log_type
+      if ConfigParser.handle_nil(log_name)
+        @log_name = (log_name.to_s + @log_type.to_s.downcase).freeze
+      else
+        @log_name = @log_type.to_s.downcase.freeze
+      end
+      @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
+      @cycle_time = ConfigParser.handle_nil(cycle_time)
+      @cycle_time = Integer(@cycle_time) if @cycle_time
+      @cycle_size = ConfigParser.handle_nil(cycle_size)
+      @cycle_size = Integer(@cycle_size) if @cycle_size
+      if ConfigParser.handle_nil(log_directory)
+        @log_directory = log_directory
+      else
+        @log_directory = System.instance.paths['LOGS']
+      end
+      @asynchronous = ConfigParser.handle_true_false(asynchronous)
+      @queue = Queue.new
+      @mutex = Mutex.new
+      @file = nil
+      @file_size = 0
+      @filename = nil
+      @label = nil
+      @entry_header = String.new
+      @start_time = Time.now.sys
+
+      @cancel_threads = false
+      @logging_thread = nil
+      if @asynchronous
+        @logging_thread = Cosmos.safe_thread("Packet log") do
+          logging_thread_body()
+        end
+      end
+
+      @cycle_thread = nil
+      if @cycle_time
+        @cycle_sleeper = Sleeper.new
+        @cycle_thread = Cosmos.safe_thread("Packet log cycle") do
+          cycle_thread_body()
+        end
+      end
+    end
+
+    # Write a packet to the log file. If the log file was created with
+    # asynchronous = true the packet will be put on a queue and written by the
+    # log writer thread. Otherwise the packet will be written in the caller's
+    # thread context.
+    #
+    # If no log file currently exists in the filesystem, a new file will be
+    # created.
+    #
+    # @param packet [Packet] The packet to write to the log file
+    def write(packet)
+      if @asynchronous
+        @queue << packet.clone
+      else
+        write_packet(packet)
+      end
+    end
+
+    # Starts a new log file by closing the existing log file. New log files are
+    # not created until packets are written by {#write} so this does not
+    # immediately create a log file on the filesystem.
+    #
+    # @param label [String] Label to append to the logfile name. This label
+    #   will be placed after the cmd or tlm in the filename. For example, if
+    #   'test' is given to a command log file, the filename will be
+    #   'YYYY_MM_DD_HH_MM_SS_cmd_test.bin'.
+    def start(label = nil)
+      new_label = label.to_s.strip
+      if new_label.length == 0
+        @label = nil
+      elsif new_label =~ /^[a-zA-Z0-9]*$/
+        @label = new_label
+      else
+        # Invalid label - Clear out existing
+        @label = nil
+      end
+
+      @mutex.synchronize { close_file(false); @logging_enabled = true }
+    end
+
+    # Stops all logging and closes the current log file.
+    def stop
+      @mutex.synchronize { @logging_enabled = false; close_file(false) }
+    end
+
+    # Stop all logging, close the current log file, and kill the logging threads.
+    def shutdown
+      stop()
+      if @cycle_thread
+        @cycle_sleeper.cancel
+        Cosmos.kill_thread(self, @cycle_thread)
+        @cycle_thread = nil
+      end
+      Cosmos.kill_thread(self, @logging_thread)
+    end
+
+    def graceful_kill
+      @cancel_threads = true
+      @queue << nil
+    end
+
+    protected
+
+    # Starting a new log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    # Assumes mutex has already been taken
+    def start_new_file(packet = nil)
+      close_file(false)
+      Cosmos.set_working_dir do
+        # Create a filename that doesn't exist
+        attempt = nil
+        while true
+          @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name, @label, attempt], '.bin'))
+          if File.exist?(@filename)
+            attempt ||= 0
+            attempt += 1
+          else
+            break
+          end
+        end
+
+        @file = File.new(@filename, 'wb')
+        @file_size = 0
+      end
+      file_header = build_file_header()
+      if file_header
+        @file.write(file_header)
+        @file_size += file_header.length
+      end
+      @start_time = Time.now.sys
+      Logger.instance.info "Log File Opened : #{@filename}"
+      start_new_file_hook(packet)
+    rescue => err
+      Logger.instance.error "Error opening #{@filename} : #{err.formatted}"
+      @logging_enabled = false
+      Cosmos.handle_critical_exception(err)
+    end
+
+    # Adds the meta packet at the beginning of telemetry packet logs
+    # Mutex is held during this hook
+    def start_new_file_hook(packet)
+      # If the first packet is a SYSTEM META packet, make sure the file header matches
+      if packet and packet.target_name == 'SYSTEM'.freeze and packet.packet_name == 'META'.freeze
+        file_header = build_file_header(packet.read('CONFIG'))
+        if file_header
+          @file.seek(0, IO::SEEK_SET)
+          @file.write(file_header)
+          @file_size = file_header.length
+        end
+      else
+        # Else log the first packet as the SYSTEM META packet
+        packet = System.telemetry.packet('SYSTEM', 'META')
+        write_packet(packet, false)
+      end
+    end
+
+    # Closing a log file isn't critical so we just log an error
+    def close_file(take_mutex = true)
+      @mutex.lock if take_mutex
+
+      begin
+        if @file
+          begin
+            @file.close unless @file.closed?
+            Cosmos.set_working_dir do
+              File.chmod(0444, @file.path) # Make file read only
+            end
+            Logger.instance.info "Log File Closed : #{@filename}"
+          rescue Exception => err
+            Logger.instance.error "Error closing #{@filename} : #{err.formatted}"
+          end
+
+          @file = nil
+          @file_size = 0
+          @filename = nil
+        end
+      ensure
+        @mutex.unlock if take_mutex
+      end
+    end
+
+    # Writing a log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    def write_packet(packet, take_mutex = true)
+      return if !packet or !@logging_enabled
+      @mutex.lock if take_mutex
+      begin
+        # This check includes logging_enabled again because it might have changed since we acquired the mutex
+        if @logging_enabled and (!@file or (@cycle_size and (@file_size + packet.length) > @cycle_size))
+          start_new_file(packet)
+        end
+        pre_write_entry_hook(packet)
+        if @file
+          @entry_header = build_entry_header(packet) # populate @entry_header
+          if @entry_header
+            @file.write(@entry_header)
+            @file_size += @entry_header.length
+          end
+          buffer = packet.buffer(false)
+          @file.write(buffer)
+          @file_size += buffer.length
+        end
+      ensure
+        @mutex.unlock if take_mutex
+      end
+    rescue => err
+      Logger.instance.error "Error writing #{@filename} : #{err.formatted}"
+      Cosmos.handle_critical_exception(err)
+    end
+
+    # Hook to allow access to the packet immediately before writing its entry
+    def pre_write_entry_hook(packet)
+    end
+
+    def logging_thread_body
+      while true
+        begin
+          packet = @queue.pop
+          return if @cancel_threads
+        rescue ThreadError
+          # This can happen when the thread is killed
+          return
+        end
+        write_packet(packet)
+      end
+    end
+
+    def cycle_thread_body
+      while true
+        # The check against start_time needs to be mutex protected to prevent a packet coming in between the check
+        # and closing the file
+        @mutex.synchronize do
+          if @logging_enabled and @cycle_time and (Time.now.sys - @start_time) > @cycle_time
+            close_file(false)
+          end
+        end
+        # Only check whether to cycle at a set interval
+        break if @cycle_sleeper.sleep(CYCLE_TIME_INTERVAL)
+      end
+    end
+
+    def build_file_header(configuration_name = System.configuration_name)
+      hostname = Socket.gethostname.to_s
+      file_header = "COSMOS2_#{@log_type}_#{configuration_name.ljust(32, ' ')[0..31]}_"
+      file_header << hostname.ljust(83)
+      return file_header
+    end
+
+    def build_entry_header(packet)
+      received_time = packet.received_time
+      received_time = Time.now.sys unless received_time
+      # This is an optimization to avoid creating a new entry_header object
+      # each time we create an entry_header which we do a LOT!
+      @entry_header.clear
+      @entry_header << [received_time.tv_sec].pack('N'.freeze)
+      @entry_header << [received_time.tv_usec].pack('N'.freeze)
+      target_name = packet.target_name
+      target_name = 'UNKNOWN'.freeze unless target_name
+      @entry_header << target_name.length
+      @entry_header << target_name
+      packet_name = packet.packet_name
+      packet_name = 'UNKNOWN'.freeze unless packet_name
+      @entry_header << packet_name.length
+      @entry_header << packet_name
+      @entry_header << [packet.length].pack('N'.freeze)
+      return @entry_header
+    end
+
+  end # class PacketLogWriter
+
+end # module Cosmos

data/lib/cosmos/packet_logs/packet_log_writer_pair.rb

@@ -0,0 +1,30 @@
+# 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
+
+  # Holds a cmd/tlm pair of packet log writers
+  class PacketLogWriterPair
+
+    # @return [PacketLogWriter] The comamnd log writer
+    attr_reader :cmd_log_writer
+    # @return [PacketLogWriter] The telemetry log writer
+    attr_reader :tlm_log_writer
+
+    # @param cmd_log_writer [PacketLogWriter] The command log writer
+    # @param tlm_log_writer [PacketLogWriter] The telemetry log writer
+    def initialize(cmd_log_writer, tlm_log_writer)
+      @cmd_log_writer = cmd_log_writer
+      @tlm_log_writer = tlm_log_writer
+    end
+
+  end # class PacketLogWriterPair
+
+end # module Cosmos

data/lib/cosmos/packets/binary_accessor.rb

@@ -0,0 +1,1201 @@
+# 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 Lesser General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+# This file contains the implementation of the BinaryAccessor class.
+# This class allows for easy reading and writing of binary data in Ruby
+
+require 'cosmos/ext/packet' if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
+
+module Cosmos
+
+  # Provides methods for binary reading and writing
+  class BinaryAccessor
+
+    # Constants for ruby packing directives
+    PACK_8_BIT_INT = 'c'
+    PACK_NATIVE_16_BIT_INT = 's'
+    PACK_LITTLE_ENDIAN_16_BIT_UINT = 'v'
+    PACK_BIG_ENDIAN_16_BIT_UINT = 'n'
+    PACK_NATIVE_32_BIT_INT = 'l'
+    PACK_NATIVE_32_BIT_UINT = 'L'
+    PACK_NATIVE_64_BIT_INT = 'q'
+    PACK_NATIVE_64_BIT_UINT = 'Q'
+    PACK_LITTLE_ENDIAN_32_BIT_UINT = 'V'
+    PACK_BIG_ENDIAN_32_BIT_UINT = 'N'
+    PACK_LITTLE_ENDIAN_32_BIT_FLOAT = 'e'
+    PACK_LITTLE_ENDIAN_64_BIT_FLOAT = 'E'
+    PACK_BIG_ENDIAN_32_BIT_FLOAT = 'g'
+    PACK_BIG_ENDIAN_64_BIT_FLOAT = 'G'
+    PACK_NULL_TERMINATED_STRING = 'Z*'
+    PACK_BLOCK = 'a*'
+    PACK_8_BIT_INT_ARRAY = 'c*'
+    PACK_8_BIT_UINT_ARRAY = 'C*'
+    PACK_NATIVE_16_BIT_INT_ARRAY = 's*'
+    PACK_BIG_ENDIAN_16_BIT_UINT_ARRAY = 'n*'
+    PACK_LITTLE_ENDIAN_16_BIT_UINT_ARRAY = 'v*'
+    PACK_NATIVE_32_BIT_INT_ARRAY = 'l*'
+    PACK_BIG_ENDIAN_32_BIT_UINT_ARRAY = 'N*'
+    PACK_LITTLE_ENDIAN_32_BIT_UINT_ARRAY = 'V*'
+    PACK_NATIVE_64_BIT_INT_ARRAY = 'q*'
+    PACK_NATIVE_64_BIT_UINT_ARRAY = 'Q*'
+    PACK_LITTLE_ENDIAN_32_BIT_FLOAT_ARRAY = 'e*'
+    PACK_LITTLE_ENDIAN_64_BIT_FLOAT_ARRAY = 'E*'
+    PACK_BIG_ENDIAN_32_BIT_FLOAT_ARRAY = 'g*'
+    PACK_BIG_ENDIAN_64_BIT_FLOAT_ARRAY = 'G*'
+
+    if RUBY_ENGINE != 'ruby' or ENV['COSMOS_NO_ENV']
+      MIN_INT8 = -128
+      MAX_INT8 = 127
+      MAX_UINT8 = 255
+      MIN_INT16 = -32768
+      MAX_INT16 = 32767
+      MAX_UINT16 = 65535
+      MIN_INT32  = -(2 ** 31)
+      MAX_INT32  = (2 ** 31) - 1
+      MAX_UINT32 = (2 ** 32) - 1
+      MIN_INT64  = -(2 ** 63)
+      MAX_INT64  = (2 ** 63) - 1
+      MAX_UINT64 = (2 ** 64) - 1
+    end
+
+    # Additional Constants
+    ZERO_STRING = "\000"
+
+    # Valid data types
+    DATA_TYPES = [:INT, :UINT, :FLOAT, :STRING, :BLOCK]
+
+    # Valid overflow types
+    OVERFLOW_TYPES = [:TRUNCATE, :SATURATE, :ERROR, :ERROR_ALLOW_HEX]
+
+    protected
+
+    # Determines the endianness of the host running this code
+    #
+    # This method is protected to force the use of the constant
+    # HOST_ENDIANNESS rather than this method
+    #
+    # @return [Symbol] :BIG_ENDIAN or :LITTLE_ENDIAN
+    def self.get_host_endianness
+      value = 0x01020304
+      packed = [value].pack(PACK_NATIVE_32_BIT_UINT)
+      unpacked = packed.unpack(PACK_LITTLE_ENDIAN_32_BIT_UINT)[0]
+      if unpacked == value
+        :LITTLE_ENDIAN
+      else
+        :BIG_ENDIAN
+      end
+    end
+
+    def self.raise_buffer_error(read_write, buffer, data_type, given_bit_offset, given_bit_size)
+      raise ArgumentError, "#{buffer.length} byte buffer insufficient to #{read_write} #{data_type} at bit_offset #{given_bit_offset} with bit_size #{given_bit_size}"
+    end
+
+    public
+
+    # Store the host endianness so that it only has to be determined once
+    HOST_ENDIANNESS = get_host_endianness()
+    # Valid endianess
+    ENDIANNESS = [:BIG_ENDIAN, :LITTLE_ENDIAN]
+
+    if RUBY_ENGINE != 'ruby' or ENV['COSMOS_NO_EXT']
+      # Reads binary data of any data type from a buffer
+      #
+      # @param bit_offset [Integer] Bit offset to the start of the item. A
+      #   negative number means to offset from the end of the buffer.
+      # @param bit_size [Integer] Size of the item in bits
+      # @param data_type [Symbol] {DATA_TYPES}
+      # @param buffer [String] Binary string buffer to read from
+      # @param endianness [Symbol] {ENDIANNESS}
+      # @return [Integer] value read from the buffer
+      def self.read(bit_offset, bit_size, data_type, buffer, endianness)
+        given_bit_offset = bit_offset
+        given_bit_size = bit_size
+
+        bit_offset = check_bit_offset_and_size(:read, given_bit_offset, given_bit_size, data_type, buffer)
+
+        # If passed a negative bit size with strings or blocks
+        # recalculate based on the buffer length
+        if (bit_size <= 0) && ((data_type == :STRING) || (data_type == :BLOCK))
+          bit_size = (buffer.length * 8) - bit_offset + bit_size
+          if bit_size == 0
+            return ""
+          elsif bit_size < 0
+            raise_buffer_error(:read, buffer, data_type, given_bit_offset, given_bit_size)
+          end
+        end
+
+        result, lower_bound, upper_bound = check_bounds_and_buffer_size(bit_offset, bit_size, buffer.length, endianness, data_type)
+        raise_buffer_error(:read, buffer, data_type, given_bit_offset, given_bit_size) unless result
+
+        if (data_type == :STRING) || (data_type == :BLOCK)
+          #######################################
+          # Handle :STRING and :BLOCK data types
+          #######################################
+
+          if byte_aligned(bit_offset)
+            if data_type == :STRING
+              return buffer[lower_bound..upper_bound].unpack('Z*')[0]
+            else
+              return buffer[lower_bound..upper_bound].unpack('a*')[0]
+            end
+          else
+            raise(ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}")
+          end
+
+        elsif (data_type == :INT) || (data_type == :UINT)
+          ###################################
+          # Handle :INT and :UINT data types
+          ###################################
+
+          if byte_aligned(bit_offset) && even_bit_size(bit_size)
+
+            if data_type == :INT
+              ###########################################################
+              # Handle byte-aligned 8, 16, 32, and 64 bit :INT
+              ###########################################################
+
+              case bit_size
+              when 8
+                return buffer[lower_bound].unpack(PACK_8_BIT_INT)[0]
+              when 16
+                if endianness == HOST_ENDIANNESS
+                  return buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_16_BIT_INT)[0]
+                else # endianness != HOST_ENDIANNESS
+                  temp = buffer[lower_bound..upper_bound].reverse
+                  return temp.unpack(PACK_NATIVE_16_BIT_INT)[0]
+                end
+              when 32
+                if endianness == HOST_ENDIANNESS
+                  return buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_32_BIT_INT)[0]
+                else # endianness != HOST_ENDIANNESS
+                  temp = buffer[lower_bound..upper_bound].reverse
+                  return temp.unpack(PACK_NATIVE_32_BIT_INT)[0]
+                end
+              when 64
+                if endianness == HOST_ENDIANNESS
+                  return buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_64_BIT_INT)[0]
+                else # endianness != HOST_ENDIANNESS
+                  temp = buffer[lower_bound..upper_bound].reverse
+                  return temp.unpack(PACK_NATIVE_64_BIT_INT)[0]
+                end
+              end
+            else # data_type == :UINT
+              ###########################################################
+              # Handle byte-aligned 8, 16, 32, and 64 bit :UINT
+              ###########################################################
+
+              case bit_size
+              when 8
+                return buffer.getbyte(lower_bound)
+              when 16
+                if endianness == :BIG_ENDIAN
+                  return buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_16_BIT_UINT)[0]
+                else # endianness == :LITTLE_ENDIAN
+                  return buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_16_BIT_UINT)[0]
+                end
+              when 32
+                if endianness == :BIG_ENDIAN
+                  return buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_32_BIT_UINT)[0]
+                else # endianness == :LITTLE_ENDIAN
+                  return buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_32_BIT_UINT)[0]
+                end
+              when 64
+                if endianness == HOST_ENDIANNESS
+                  return buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_64_BIT_UINT)[0]
+                else # endianness != HOST_ENDIANNESS
+                  temp = buffer[lower_bound..upper_bound].reverse
+                  return temp.unpack(PACK_NATIVE_64_BIT_UINT)[0]
+                end
+              end
+            end
+
+          else
+            ##########################
+            # Handle :INT and :UINT Bitfields
+            ##########################
+
+            #Extract Data for Bitfield
+            if endianness == :LITTLE_ENDIAN
+              #Bitoffset always refers to the most significant bit of a bitfield
+              num_bytes = (((bit_offset % 8) + bit_size - 1) / 8) + 1
+              upper_bound = bit_offset / 8
+              lower_bound = upper_bound - num_bytes + 1
+
+              if lower_bound < 0
+                raise(ArgumentError, "LITTLE_ENDIAN bitfield with bit_offset #{given_bit_offset} and bit_size #{given_bit_size} is invalid")
+              end
+
+              temp_data = buffer[lower_bound..upper_bound].reverse
+            else
+              temp_data = buffer[lower_bound..upper_bound]
+            end
+
+            #Determine temp upper bound
+            temp_upper = upper_bound - lower_bound
+
+            # Handle Bitfield
+            start_bits = bit_offset % 8
+            start_mask = ~(0xFF << (8 - start_bits))
+            total_bits = (temp_upper + 1) * 8
+            right_shift = total_bits - start_bits - bit_size
+
+            #Mask off unwanted bits at beginning
+            temp = temp_data.getbyte(0) & start_mask
+
+            if upper_bound > lower_bound
+              #Combine bytes into a FixNum
+              temp_data[1..temp_upper].each_byte {|temp_value| temp = temp << 8; temp = temp + temp_value }
+            end
+
+            # Shift off unwanted bits at end
+            temp = temp >> right_shift
+
+            if data_type == :INT
+              #Convert to negative if necessary
+              if ((bit_size > 1) && (temp[bit_size - 1] == 1))
+                temp = -((1 << bit_size) - temp)
+              end
+            end
+
+            return temp
+          end
+
+        elsif data_type == :FLOAT
+          ##########################
+          # Handle :FLOAT data type
+          ##########################
+
+          if byte_aligned(bit_offset)
+            case bit_size
+            when 32
+              if endianness == :BIG_ENDIAN
+                return buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_32_BIT_FLOAT)[0]
+              else # endianness == :LITTLE_ENDIAN
+                return buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT)[0]
+              end
+            when 64
+              if endianness == :BIG_ENDIAN
+                return buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_64_BIT_FLOAT)[0]
+              else # endianness == :LITTLE_ENDIAN
+                return buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT)[0]
+              end
+            else
+              raise(ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}")
+            end
+          else
+            raise(ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}")
+          end
+
+        else
+          ############################
+          # Handle Unknown data types
+          ############################
+
+          raise(ArgumentError, "data_type #{data_type} is not recognized")
+        end
+
+        return return_value
+      end
+
+      # Writes binary data of any data type to a buffer
+      #
+      # @param value [Varies] Value to write into the buffer
+      # @param bit_offset [Integer] Bit offset to the start of the item. A
+      #   negative number means to offset from the end of the buffer.
+      # @param bit_size [Integer] Size of the item in bits
+      # @param data_type [Symbol] {DATA_TYPES}
+      # @param buffer [String] Binary string buffer to write to
+      # @param endianness [Symbol] {ENDIANNESS}
+      # @param overflow [Symbol] {OVERFLOW_TYPES}
+      # @return [Integer] value passed in as a parameter
+      def self.write(value, bit_offset, bit_size, data_type, buffer, endianness, overflow)
+        given_bit_offset = bit_offset
+        given_bit_size = bit_size
+
+        bit_offset = check_bit_offset_and_size(:write, given_bit_offset, given_bit_size, data_type, buffer)
+
+        # If passed a negative bit size with strings or blocks
+        # recalculate based on the value length in bytes
+        if (bit_size <= 0) && ((data_type == :STRING) || (data_type == :BLOCK))
+          value = value.to_s
+          bit_size = value.length * 8
+        end
+
+        result, lower_bound, upper_bound = check_bounds_and_buffer_size(bit_offset, bit_size, buffer.length, endianness, data_type)
+        raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size) if !result && (given_bit_size > 0)
+
+        # Check overflow type
+        if (overflow != :TRUNCATE) && (overflow != :SATURATE) && (overflow != :ERROR) && (overflow != :ERROR_ALLOW_HEX)
+          raise(ArgumentError, "unknown overflow type #{overflow}")
+        end
+
+        if (data_type == :STRING) || (data_type == :BLOCK)
+          #######################################
+          # Handle :STRING and :BLOCK data types
+          #######################################
+          value = value.to_s
+
+          if byte_aligned(bit_offset)
+            temp = value
+            if given_bit_size <= 0
+              end_bytes = -(given_bit_size / 8)
+              old_upper_bound = buffer.length - 1 - end_bytes
+              # Lower bound + end_bytes can never be more than 1 byte outside of the given buffer
+              if (lower_bound + end_bytes) > buffer.length
+                raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size)
+              end
+
+              if old_upper_bound < lower_bound
+                # String was completely empty
+                if end_bytes > 0
+                  # Preserve bytes at end of buffer
+                  buffer_length = buffer.length
+                  buffer << "\000" * value.length
+                  buffer[lower_bound + value.length, end_bytes] = buffer[lower_bound, end_bytes]
+                end
+              elsif bit_size == 0
+                # Remove entire string
+                buffer[lower_bound, old_upper_bound - lower_bound + 1] = ''
+              elsif upper_bound < old_upper_bound
+                # Remove extra bytes from old string
+                buffer[upper_bound + 1, old_upper_bound - upper_bound] = ''
+              elsif (upper_bound > old_upper_bound) && (end_bytes > 0)
+                # Preserve bytes at end of buffer
+                buffer_length = buffer.length
+                diff = upper_bound - old_upper_bound
+                buffer << "\000" * diff
+                buffer[upper_bound + 1, end_bytes] = buffer[old_upper_bound + 1, end_bytes]
+              end
+            else # given_bit_size > 0
+              byte_size = bit_size / 8
+              if value.length < byte_size
+                # Pad the requested size with zeros
+                temp = value.ljust(byte_size, "\000")
+              elsif value.length > byte_size
+                if overflow == :TRUNCATE
+                  # Resize the value to fit the field
+                  value[byte_size, value.length - byte_size] = ''
+                else
+                  raise(ArgumentError, "value of #{value.length} bytes does not fit into #{byte_size} bytes for data_type #{data_type}")
+                end
+              end
+            end
+            if bit_size != 0
+              buffer[lower_bound, temp.length] = temp
+            end
+          else
+            raise(ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}")
+          end
+
+        elsif (data_type == :INT) || (data_type == :UINT)
+          ###################################
+          # Handle :INT data type
+          ###################################
+          value = Integer(value)
+          min_value, max_value, hex_max_value = get_check_overflow_ranges(bit_size, data_type)
+          value = check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
+
+          if byte_aligned(bit_offset) && even_bit_size(bit_size)
+            ###########################################################
+            # Handle byte-aligned 8, 16, 32, and 64 bit
+            ###########################################################
+
+            if data_type == :INT
+              ###########################################################
+              # Handle byte-aligned 8, 16, 32, and 64 bit :INT
+              ###########################################################
+
+              case bit_size
+              when 8
+                buffer.setbyte(lower_bound, value)
+              when 16
+                if endianness == HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_16_BIT_INT)
+                else # endianness != HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_16_BIT_INT).reverse
+                end
+              when 32
+                if endianness == HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_32_BIT_INT)
+                else # endianness != HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_32_BIT_INT).reverse
+                end
+              when 64
+                if endianness == HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_INT)
+                else # endianness != HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_INT).reverse
+                end
+              end
+            else # data_type == :UINT
+              ###########################################################
+              # Handle byte-aligned 8, 16, 32, and 64 bit :UINT
+              ###########################################################
+
+              case bit_size
+              when 8
+                buffer.setbyte(lower_bound, value)
+              when 16
+                if endianness == :BIG_ENDIAN
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_16_BIT_UINT)
+                else # endianness == :LITTLE_ENDIAN
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_16_BIT_UINT)
+                end
+              when 32
+                if endianness == :BIG_ENDIAN
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_32_BIT_UINT)
+                else # endianness == :LITTLE_ENDIAN
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_32_BIT_UINT)
+                end
+              when 64
+                if endianness == HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_UINT)
+                else # endianness != HOST_ENDIANNESS
+                  buffer[lower_bound..upper_bound] = [value].pack(PACK_NATIVE_64_BIT_UINT).reverse
+                end
+              end
+            end
+
+          else
+            ###########################################################
+            # Handle bit fields
+            ###########################################################
+
+            # Extract Existing Data
+            if endianness == :LITTLE_ENDIAN
+              # Bitoffset always refers to the most significant bit of a bitfield
+              num_bytes = (((bit_offset % 8) + bit_size - 1) / 8) + 1
+              upper_bound = bit_offset / 8
+              lower_bound = upper_bound - num_bytes + 1
+              if lower_bound < 0
+                raise(ArgumentError, "LITTLE_ENDIAN bitfield with bit_offset #{given_bit_offset} and bit_size #{given_bit_size} is invalid")
+              end
+              temp_data = buffer[lower_bound..upper_bound].reverse
+            else
+              temp_data = buffer[lower_bound..upper_bound]
+            end
+
+            # Determine temp upper bound
+            temp_upper = upper_bound - lower_bound
+
+            # Determine Values needed to Handle Bitfield
+            start_bits = bit_offset % 8
+            start_mask = (0xFF << (8 - start_bits))
+            total_bits = (temp_upper + 1) * 8
+            end_bits = total_bits - start_bits - bit_size
+            end_mask = ~(0xFF << end_bits)
+
+            # Add in Start Bits
+            temp = temp_data.getbyte(0) & start_mask
+
+            # Adjust value to correct number of bits
+            temp_mask = (2 ** bit_size) - 1
+            temp_value = value & temp_mask
+
+            # Add in New Data
+            temp = (temp << (bit_size - (8 - start_bits))) + temp_value
+
+            # Add in Remainder of Existing Data
+            temp = (temp << end_bits) + (temp_data.getbyte(temp_upper) & end_mask)
+
+            # Extract into an array of bytes
+            temp_array = []
+            (0..temp_upper).each { temp_array.insert(0, (temp & 0xFF)); temp = temp >> 8 }
+
+            # Store into data
+            if endianness == :LITTLE_ENDIAN
+              buffer[lower_bound..upper_bound] = temp_array.pack(PACK_8_BIT_UINT_ARRAY).reverse
+            else
+              buffer[lower_bound..upper_bound] = temp_array.pack(PACK_8_BIT_UINT_ARRAY)
+            end
+
+          end
+
+        elsif data_type == :FLOAT
+          ##########################
+          # Handle :FLOAT data type
+          ##########################
+          value = Float(value)
+
+          if byte_aligned(bit_offset)
+            case bit_size
+            when 32
+              if endianness == :BIG_ENDIAN
+                buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_32_BIT_FLOAT)
+              else # endianness == :LITTLE_ENDIAN
+                buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT)
+              end
+            when 64
+              if endianness == :BIG_ENDIAN
+                buffer[lower_bound..upper_bound] = [value].pack(PACK_BIG_ENDIAN_64_BIT_FLOAT)
+              else # endianness == :LITTLE_ENDIAN
+                buffer[lower_bound..upper_bound] = [value].pack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT)
+              end
+            else
+              raise(ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}")
+            end
+          else
+            raise(ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}")
+          end
+
+        else
+          ############################
+          # Handle Unknown data types
+          ############################
+
+          raise(ArgumentError, "data_type #{data_type} is not recognized")
+        end
+
+        return value
+      end
+
+      protected
+
+      # Check the bit size and bit offset for problems. Recalulate the bit offset
+      # and return back through the passed in pointer.
+      def self.check_bit_offset_and_size(read_or_write, given_bit_offset, given_bit_size, data_type, buffer)
+        bit_offset = given_bit_offset
+
+        if (given_bit_size <= 0) && (data_type != :STRING) && (data_type != :BLOCK)
+          raise(ArgumentError, "bit_size #{given_bit_size} must be positive for data types other than :STRING and :BLOCK")
+        end
+
+        if (given_bit_size <= 0) && (given_bit_offset < 0)
+          raise(ArgumentError, "negative or zero bit_sizes (#{given_bit_size}) cannot be given with negative bit_offsets (#{given_bit_offset})")
+        end
+
+        if given_bit_offset < 0
+          bit_offset = (buffer.length * 8) + bit_offset
+          if bit_offset < 0
+            raise_buffer_error(read_or_write, buffer, data_type, given_bit_offset, given_bit_size)
+          end
+        end
+
+        return bit_offset
+      end
+
+      # Calculate the bounds of the string to access the item based on the bit_offset and bit_size.
+      # Also determine if the buffer size is sufficient.
+      def self.check_bounds_and_buffer_size(bit_offset, bit_size, buffer_length, endianness, data_type)
+        result = true # Assume ok
+
+        # Define bounds of string to access this item
+        lower_bound = bit_offset / 8
+        upper_bound = (bit_offset + bit_size - 1) / 8
+
+        # Sanity check buffer size
+        if upper_bound >= buffer_length
+          # If it's not the special case of little endian bit field then we fail and return false
+          if !( (endianness == :LITTLE_ENDIAN) &&
+                 ((data_type == :INT) || (data_type == :UINT)) &&
+                 # Not byte aligned with an even bit size
+                 (!( (byte_aligned(bit_offset)) && (even_bit_size(bit_size)) )) &&
+                 (lower_bound < buffer_length)
+             )
+            result = false
+          end
+        end
+        return result, lower_bound, upper_bound
+      end
+
+      def self.get_check_overflow_ranges(bit_size, data_type)
+        min_value = 0 # Default for UINT cases
+
+        case bit_size
+        when 8
+          hex_max_value = MAX_UINT8
+          if data_type == :INT
+            min_value = MIN_INT8
+            max_value = MAX_INT8
+          else
+            max_value = MAX_UINT8
+          end
+        when 16
+          hex_max_value = MAX_UINT16
+          if data_type == :INT
+            min_value = MIN_INT16
+            max_value = MAX_INT16
+          else
+            max_value = MAX_UINT16
+          end
+        when 32
+          hex_max_value = MAX_UINT32
+          if data_type == :INT
+            min_value = MIN_INT32
+            max_value = MAX_INT32
+          else
+            max_value = MAX_UINT32
+          end
+        when 64
+          hex_max_value = MAX_UINT64
+          if data_type == :INT
+            min_value = MIN_INT64
+            max_value = MAX_INT64
+          else
+            max_value = MAX_UINT64
+          end
+        else # Bitfield
+          if data_type == :INT
+            # Note signed integers must allow up to the maximum unsigned value to support values given in hex
+            if bit_size > 1
+              max_value = 2 ** (bit_size - 1)
+              # min_value = -(2 ** bit_size - 1)
+              min_value = -max_value
+              # max_value = (2 ** bit_size - 1) - 1
+              max_value -= 1
+              # hex_max_value = (2 ** bit_size) - 1
+              hex_max_value = (2 ** bit_size) - 1
+            else # 1-bit signed
+              min_value = -1
+              max_value = 1
+              hex_max_value = 1
+            end
+          else
+            max_value = (2 ** bit_size) - 1
+            hex_max_value = max_value
+          end
+        end
+
+        return min_value, max_value, hex_max_value
+      end
+
+      def self.byte_aligned(value)
+        (value % 8) == 0
+      end
+
+      def self.even_bit_size(bit_size)
+        (bit_size == 8) || (bit_size == 16) || (bit_size == 32) || (bit_size == 64)
+      end
+
+      public
+    end
+
+    # Reads an array of binary data of any data type from a buffer
+    #
+    # @param bit_offset [Integer] Bit offset to the start of the array. A
+    #   negative number means to offset from the end of the buffer.
+    # @param bit_size [Integer] Size of each item in the array in bits
+    # @param data_type [Symbol] {DATA_TYPES}
+    # @param array_size [Integer] Size in bits of the array. 0 or negative means
+    #   fill the array with as many bit_size number of items that exist (negative
+    #   means excluding the final X number of bits).
+    # @param buffer [String] Binary string buffer to read from
+    # @param endianness [Symbol] {ENDIANNESS}
+    # @return [Array] Array created from reading the buffer
+    def self.read_array(bit_offset, bit_size, data_type, array_size, buffer, endianness)
+      # Save given values of bit offset, bit size, and array_size
+      given_bit_offset = bit_offset
+      given_bit_size = bit_size
+      given_array_size = array_size
+
+      # Handle negative and zero bit sizes
+      raise ArgumentError, "bit_size #{given_bit_size} must be positive for arrays" if bit_size <= 0
+
+      # Handle negative bit offsets
+      if bit_offset < 0
+        bit_offset = ((buffer.length * 8) + bit_offset)
+        raise_buffer_error(:read, buffer, data_type, given_bit_offset, given_bit_size) if bit_offset < 0
+      end
+
+      # Handle negative and zero array sizes
+      if array_size <= 0
+        if given_bit_offset < 0
+          raise ArgumentError, "negative or zero array_size (#{given_array_size}) cannot be given with negative bit_offset (#{given_bit_offset})"
+        else
+          array_size = ((buffer.length * 8) - bit_offset + array_size)
+          if array_size == 0
+            return []
+          elsif array_size < 0
+            raise_buffer_error(:read, buffer, data_type, given_bit_offset, given_bit_size)
+          end
+        end
+      end
+
+      # Calculate number of items in the array
+      # If there is a remainder then we have a problem
+      raise ArgumentError, "array_size #{given_array_size} not a multiple of bit_size #{given_bit_size}" if array_size % bit_size != 0
+      num_items = array_size / bit_size
+
+      # Define bounds of string to access this item
+      lower_bound = bit_offset / 8
+      upper_bound = (bit_offset + array_size - 1) / 8
+
+      # Check for byte alignment
+      byte_aligned = ((bit_offset % 8) == 0)
+
+      case data_type
+      when :STRING, :BLOCK
+        #######################################
+        # Handle :STRING and :BLOCK data types
+        #######################################
+
+        if byte_aligned
+          value = []
+          num_items.times do
+            value << self.read(bit_offset, bit_size, data_type, buffer, endianness)
+            bit_offset += bit_size
+          end
+        else
+          raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
+        end
+
+      when :INT, :UINT
+        ###################################
+        # Handle :INT and :UINT data types
+        ###################################
+
+        if byte_aligned and (bit_size == 8 or bit_size == 16 or bit_size == 32 or bit_size == 64)
+          ###########################################################
+          # Handle byte-aligned 8, 16, 32, and 64 bit :INT and :UINT
+          ###########################################################
+
+          case bit_size
+          when 8
+            if data_type == :INT
+              value = buffer[lower_bound..upper_bound].unpack(PACK_8_BIT_INT_ARRAY)
+            else # data_type == :UINT
+              value = buffer[lower_bound..upper_bound].unpack(PACK_8_BIT_UINT_ARRAY)
+            end
+
+          when 16
+            if data_type == :INT
+              if endianness == HOST_ENDIANNESS
+                value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_16_BIT_INT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 2)
+                value = temp.to_s.unpack(PACK_NATIVE_16_BIT_INT_ARRAY)
+              end
+            else # data_type == :UINT
+              if endianness == :BIG_ENDIAN
+                value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_16_BIT_UINT_ARRAY)
+              else # endianness == :LITTLE_ENDIAN
+                value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_16_BIT_UINT_ARRAY)
+              end
+            end
+
+          when 32
+            if data_type == :INT
+              if endianness == HOST_ENDIANNESS
+                value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_32_BIT_INT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 4)
+                value = temp.to_s.unpack(PACK_NATIVE_32_BIT_INT_ARRAY)
+              end
+            else # data_type == :UINT
+              if endianness == :BIG_ENDIAN
+                value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_32_BIT_UINT_ARRAY)
+              else # endianness == :LITTLE_ENDIAN
+                value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_32_BIT_UINT_ARRAY)
+              end
+            end
+
+          when 64
+            if data_type == :INT
+              if endianness == HOST_ENDIANNESS
+                value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_64_BIT_INT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 8)
+                value = temp.to_s.unpack(PACK_NATIVE_64_BIT_INT_ARRAY)
+              end
+            else # data_type == :UINT
+              if endianness == HOST_ENDIANNESS
+                value = buffer[lower_bound..upper_bound].unpack(PACK_NATIVE_64_BIT_UINT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                temp = self.byte_swap_buffer(buffer[lower_bound..upper_bound], 8)
+                value = temp.to_s.unpack(PACK_NATIVE_64_BIT_UINT_ARRAY)
+              end
+            end
+          end
+
+        else
+          ##################################
+          # Handle :INT and :UINT Bitfields
+          ##################################
+          raise ArgumentError, "read_array does not support little endian bit fields with bit_size greater than 1-bit" if endianness == :LITTLE_ENDIAN and bit_size > 1
+
+          value = []
+          num_items.times do
+            value << self.read(bit_offset, bit_size, data_type, buffer, endianness)
+            bit_offset += bit_size
+          end
+        end
+
+      when :FLOAT
+        ##########################
+        # Handle :FLOAT data type
+        ##########################
+
+        if byte_aligned
+          case bit_size
+          when 32
+            if endianness == :BIG_ENDIAN
+              value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_32_BIT_FLOAT_ARRAY)
+            else # endianness == :LITTLE_ENDIAN
+              value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT_ARRAY)
+            end
+
+          when 64
+            if endianness == :BIG_ENDIAN
+              value = buffer[lower_bound..upper_bound].unpack(PACK_BIG_ENDIAN_64_BIT_FLOAT_ARRAY)
+            else # endianness == :LITTLE_ENDIAN
+              value = buffer[lower_bound..upper_bound].unpack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT_ARRAY)
+            end
+
+          else
+            raise ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}"
+          end
+
+        else
+          raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
+        end
+
+      else
+        ############################
+        # Handle Unknown data types
+        ############################
+
+        raise ArgumentError, "data_type #{data_type} is not recognized"
+      end
+
+      value
+    end # def read_array
+
+    # Writes an array of binary data of any data type to a buffer
+    #
+    # @param values [Array] Values to write into the buffer
+    # @param bit_offset [Integer] Bit offset to the start of the array. A
+    #   negative number means to offset from the end of the buffer.
+    # @param bit_size [Integer] Size of each item in the array in bits
+    # @param data_type [Symbol] {DATA_TYPES}
+    # @param array_size [Integer] Size in bits of the array as represented in the buffer.
+    #   Size 0 means to fill the buffer with as many bit_size number of items that exist
+    #   (negative means excluding the final X number of bits).
+    # @param buffer [String] Binary string buffer to write to
+    # @param endianness [Symbol] {ENDIANNESS}
+    # @return [Array] values passed in as a parameter
+    def self.write_array(values, bit_offset, bit_size, data_type, array_size, buffer, endianness, overflow)
+      # Save given values of bit offset, bit size, and array_size
+      given_bit_offset = bit_offset
+      given_bit_size = bit_size
+      given_array_size = array_size
+
+      # Verify an array was given
+      raise ArgumentError, "values must be an Array type class is #{values.class}" unless values.kind_of? Array
+
+      # Handle negative and zero bit sizes
+      raise ArgumentError, "bit_size #{given_bit_size} must be positive for arrays" if bit_size <= 0
+
+      # Handle negative bit offsets
+      if bit_offset < 0
+        bit_offset = ((buffer.length * 8) + bit_offset)
+        raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size) if bit_offset < 0
+      end
+
+      # Handle negative and zero array sizes
+      if array_size <= 0
+        if given_bit_offset < 0
+          raise ArgumentError, "negative or zero array_size (#{given_array_size}) cannot be given with negative bit_offset (#{given_bit_offset})"
+        else
+          end_bytes = -(given_array_size / 8)
+          lower_bound = bit_offset / 8
+          upper_bound = (bit_offset + (bit_size * values.length) - 1) / 8
+          old_upper_bound = buffer.length - 1 - end_bytes
+
+          if upper_bound < old_upper_bound
+            # Remove extra bytes from old buffer
+            buffer[(upper_bound + 1)..old_upper_bound] = ''
+          elsif upper_bound > old_upper_bound
+            # Grow buffer and preserve bytes at end of buffer if necesssary
+            buffer_length = buffer.length
+            diff = upper_bound - old_upper_bound
+            buffer << ZERO_STRING * diff
+            if end_bytes > 0
+              buffer[(upper_bound + 1)..(buffer.length - 1)] = buffer[(old_upper_bound + 1)..(buffer_length - 1)]
+            end
+          end
+
+          array_size = ((buffer.length * 8) - bit_offset + array_size)
+        end
+      end
+
+      # Get data bounds for this array
+      lower_bound = bit_offset / 8
+      upper_bound = (bit_offset + array_size - 1) / 8
+      num_bytes   = upper_bound - lower_bound + 1
+
+      # Check for byte alignment
+      byte_aligned = ((bit_offset % 8) == 0)
+
+      # Calculate the number of writes
+      num_writes = array_size / bit_size
+      # Check for a negative array_size and adjust the number of writes
+      # to simply be the number of values in the passed in array
+      if given_array_size <= 0
+        num_writes = values.length
+      end
+
+      # Ensure the buffer has enough room
+      if bit_offset + num_writes * bit_size > buffer.length * 8
+        raise_buffer_error(:write, buffer, data_type, given_bit_offset, given_bit_size)
+      end
+
+      # Ensure the given_array_size is an even multiple of bit_size
+      raise ArgumentError, "array_size #{given_array_size} not a multiple of bit_size #{given_bit_size}" if array_size % bit_size != 0
+
+      raise ArgumentError, "too many values #{values.length} for given array_size #{given_array_size} and bit_size #{given_bit_size}" if num_writes < values.length
+
+      # Check overflow type
+      raise "unknown overflow type #{overflow}" unless OVERFLOW_TYPES.include?(overflow)
+
+      case data_type
+      when :STRING, :BLOCK
+        #######################################
+        # Handle :STRING and :BLOCK data types
+        #######################################
+
+        if byte_aligned
+          num_writes.times do |index|
+            self.write(values[index], bit_offset, bit_size, data_type, buffer, endianness, overflow)
+            bit_offset += bit_size
+          end
+        else
+          raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
+        end
+
+      when :INT, :UINT
+        ###################################
+        # Handle :INT and :UINT data types
+        ###################################
+
+        if byte_aligned and (bit_size == 8 or bit_size == 16 or bit_size == 32 or bit_size == 64)
+          ###########################################################
+          # Handle byte-aligned 8, 16, 32, and 64 bit :INT and :UINT
+          ###########################################################
+
+          case bit_size
+          when 8
+            if data_type == :INT
+              values = self.check_overflow_array(values, MIN_INT8, MAX_INT8, MAX_UINT8, bit_size, data_type, overflow)
+              packed = values.pack(PACK_8_BIT_INT_ARRAY)
+            else # data_type == :UINT
+              values = self.check_overflow_array(values, 0, MAX_UINT8, MAX_UINT8, bit_size, data_type, overflow)
+              packed = values.pack(PACK_8_BIT_UINT_ARRAY)
+            end
+
+          when 16
+            if data_type == :INT
+              values = self.check_overflow_array(values, MIN_INT16, MAX_INT16, MAX_UINT16, bit_size, data_type, overflow)
+              if endianness == HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_16_BIT_INT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_16_BIT_INT_ARRAY)
+                self.byte_swap_buffer!(packed, 2)
+              end
+            else # data_type == :UINT
+              values = self.check_overflow_array(values, 0, MAX_UINT16, MAX_UINT16, bit_size, data_type, overflow)
+              if endianness == :BIG_ENDIAN
+                packed = values.pack(PACK_BIG_ENDIAN_16_BIT_UINT_ARRAY)
+              else # endianness == :LITTLE_ENDIAN
+                packed = values.pack(PACK_LITTLE_ENDIAN_16_BIT_UINT_ARRAY)
+              end
+            end
+
+          when 32
+            if data_type == :INT
+              values = self.check_overflow_array(values, MIN_INT32, MAX_INT32, MAX_UINT32, bit_size, data_type, overflow)
+              if endianness == HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_32_BIT_INT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_32_BIT_INT_ARRAY)
+                self.byte_swap_buffer!(packed, 4)
+              end
+            else # data_type == :UINT
+              values = self.check_overflow_array(values, 0, MAX_UINT32, MAX_UINT32, bit_size, data_type, overflow)
+              if endianness == :BIG_ENDIAN
+                packed = values.pack(PACK_BIG_ENDIAN_32_BIT_UINT_ARRAY)
+              else # endianness == :LITTLE_ENDIAN
+                packed = values.pack(PACK_LITTLE_ENDIAN_32_BIT_UINT_ARRAY)
+              end
+            end
+
+          when 64
+            if data_type == :INT
+              values = self.check_overflow_array(values, MIN_INT64, MAX_INT64, MAX_UINT64, bit_size, data_type, overflow)
+              if endianness == HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_64_BIT_INT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_64_BIT_INT_ARRAY)
+                self.byte_swap_buffer!(packed, 8)
+              end
+            else # data_type == :UINT
+              values = self.check_overflow_array(values, 0, MAX_UINT64, MAX_UINT64, bit_size, data_type, overflow)
+              if endianness == HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_64_BIT_UINT_ARRAY)
+              else # endianness != HOST_ENDIANNESS
+                packed = values.pack(PACK_NATIVE_64_BIT_UINT_ARRAY)
+                self.byte_swap_buffer!(packed, 8)
+              end
+            end
+          end
+
+          # Adjust packed size to hold number of items written
+          buffer[lower_bound..upper_bound] = adjust_packed_size(num_bytes, packed) if num_bytes > 0
+
+        else
+          ##################################
+          # Handle :INT and :UINT Bitfields
+          ##################################
+
+          raise ArgumentError, "write_array does not support little endian bit fields with bit_size greater than 1-bit" if endianness == :LITTLE_ENDIAN and bit_size > 1
+
+          num_writes.times do |index|
+            self.write(values[index], bit_offset, bit_size, data_type, buffer, endianness, overflow)
+            bit_offset += bit_size
+          end
+        end
+
+      when :FLOAT
+        ##########################
+        # Handle :FLOAT data type
+        ##########################
+
+        if byte_aligned
+          case bit_size
+          when 32
+            if endianness == :BIG_ENDIAN
+              packed = values.pack(PACK_BIG_ENDIAN_32_BIT_FLOAT_ARRAY)
+            else # endianness == :LITTLE_ENDIAN
+              packed = values.pack(PACK_LITTLE_ENDIAN_32_BIT_FLOAT_ARRAY)
+            end
+
+          when 64
+            if endianness == :BIG_ENDIAN
+              packed = values.pack(PACK_BIG_ENDIAN_64_BIT_FLOAT_ARRAY)
+            else # endianness == :LITTLE_ENDIAN
+              packed = values.pack(PACK_LITTLE_ENDIAN_64_BIT_FLOAT_ARRAY)
+            end
+
+          else
+            raise ArgumentError, "bit_size is #{given_bit_size} but must be 32 or 64 for data_type #{data_type}"
+          end
+
+          # Adjust packed size to hold number of items written
+          buffer[lower_bound..upper_bound] = adjust_packed_size(num_bytes, packed) if num_bytes > 0
+
+        else
+          raise ArgumentError, "bit_offset #{given_bit_offset} is not byte aligned for data_type #{data_type}"
+        end
+
+      else
+        ############################
+        # Handle Unknown data types
+        ############################
+        raise ArgumentError, "data_type #{data_type} is not recognized"
+      end # case data_type
+
+      values
+    end # def write_array
+
+    # Adjusts the packed array to be the given number of bytes
+    #
+    # @param num_bytes [Integer] The desired number of bytes
+    # @param packed [Array] The packed data buffer
+    def self.adjust_packed_size(num_bytes, packed)
+      difference = num_bytes - packed.length
+      if difference > 0
+        packed << (ZERO_STRING * difference)
+      elsif difference < 0
+        packed = packed[0..(packed.length - 1 + difference)]
+      end
+      packed
+    end
+
+    # Byte swaps every X bytes of data in a buffer overwriting the buffer
+    #
+    # @param buffer [String] Buffer to modify
+    # @param num_bytes_per_word [Integer] Number of bytes per word that will be swapped
+    # @return [String] buffer passed in as a parameter
+    def self.byte_swap_buffer!(buffer, num_bytes_per_word)
+      num_swaps = buffer.length / num_bytes_per_word
+      index = 0
+      num_swaps.times do
+        range = index..(index + num_bytes_per_word - 1)
+        buffer[range] = buffer[range].reverse
+        index += num_bytes_per_word
+      end
+      buffer
+    end
+
+    # Byte swaps every X bytes of data in a buffer into a new buffer
+    #
+    # @param buffer [String] Buffer that will be copied then modified
+    # @param num_bytes_per_word [Integer] Number of bytes per word that will be swapped
+    # @return [String] modified buffer
+    def self.byte_swap_buffer(buffer, num_bytes_per_word)
+      buffer = buffer.clone
+      self.byte_swap_buffer!(buffer, num_bytes_per_word)
+    end
+
+    # Checks for overflow of an integer data type
+    #
+    # @param value [Integer] Value to write into the buffer
+    # @param min_value [Integer] Minimum allowed value
+    # @param max_value [Integer] Maximum allowed value
+    # @param hex_max_value [Integer] Maximum allowed value if specified in hex
+    # @param bit_size [Integer] Size of the item in bits
+    # @param data_type [Symbol] {DATA_TYPES}
+    # @param overflow [Symbol] {OVERFLOW_TYPES}
+    # @return [Integer] Potentially modified value
+    def self.check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
+      if overflow == :TRUNCATE
+        # Note this will always convert to unsigned equivalent for signed integers
+        value = value % (hex_max_value + 1)
+      else
+        if value > max_value
+          if overflow == :SATURATE
+            value = max_value
+          else
+            if overflow == :ERROR or value > hex_max_value
+              raise ArgumentError, "value of #{value} invalid for #{bit_size}-bit #{data_type}"
+            end
+          end
+        elsif value < min_value
+          if overflow == :SATURATE
+            value = min_value
+          else
+            raise ArgumentError, "value of #{value} invalid for #{bit_size}-bit #{data_type}"
+          end
+        end
+      end
+      value
+    end
+
+    # Checks for overflow of an array of integer data types
+    #
+    # @param values [Array[Integer]] Values to write into the buffer
+    # @param min_value [Integer] Minimum allowed value
+    # @param max_value [Integer] Maximum allowed value
+    # @param hex_max_value [Integer] Maximum allowed value if specified in hex
+    # @param bit_size [Integer] Size of the item in bits
+    # @param data_type [Symbol] {DATA_TYPES}
+    # @param overflow [Symbol] {OVERFLOW_TYPES}
+    # @return [Array[Integer]] Potentially modified values
+    def self.check_overflow_array(values, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
+      if overflow != :TRUNCATE
+        values.each_with_index do |value, index|
+          values[index] = check_overflow(value, min_value, max_value, hex_max_value, bit_size, data_type, overflow)
+        end
+      end
+      values
+    end
+
+  end # class BinaryAccessor
+
+end # module Cosmos