px4_log_reader 0.0.7 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0490cff29bd96afe03a73177375e181a7c5ee9f1
-  data.tar.gz: 98611a918006a2d12bbaedf6656db34b39f2ed9f
+  metadata.gz: 4c75862bd918e0d1d080d9b7a4cb52d342ddd3b8
+  data.tar.gz: 2002ad3763f5a4cd976264036b7a7b7733aebbd7
 SHA512:
-  metadata.gz: cf1783f773a16c17214a83167cf16ae520c6b3c59e2521068f54fd3620d6f3d244d1ca01b6546f3a85935a849279bd9cfc0b28c14004f247a5436f5102131ef4
-  data.tar.gz: 8f653267c2e89885394f3a2a990e28b9af69cda03eef319d65c90cc6b7431a8a75fe206d2e3d971c2024051b5324e5f01feade8ea784b447cb300d261fba4ba4
+  metadata.gz: c95423a6772f8ce0c6243bdb2b528d21b47f86784d91de05a154877db24a8a08cae4ddbff196b691fe84bc253785c5e3dec356a24ed1a4d7c377ad4ef75a38a1
+  data.tar.gz: b87364ae76b58ae13fa860358c8973fd68351fd328a1b99f117773ab53f5964f8be3851400a820ed382ea2e1da2d7f38a0aca37d624d482b6510110c7e325ebf

data/.gitignore

@@ -2,3 +2,4 @@
 .DS_Store
 *.gem
 default_log_path.txt
+descriptors.txt

data/Rakefile

@@ -131,7 +131,7 @@ task :cut_log, :count, :skip, :filename do |t,args|
 
 			read_count = args[:count].to_i
 			read_count.times do
-				message = Px4LogReader::LogFile.read_message( input, message_descriptors )
+				message, offset = Px4LogReader::LogFile.read_message( input, message_descriptors )
 				Px4LogReader::LogFile.write_message( output, message )
 			end
 		end
@@ -148,7 +148,9 @@ task :dump, :filename do |t,args|
 
 	File.open( args[:filename], 'r' ) do |input|
 		count = 1
-		while ( message = Px4LogReader::LogFile.read_message( input, message_descriptors ) ) do
+		loop do
+			message, offset = Px4LogReader::LogFile.read_message( input, message_descriptors )
+			break if message.nil?
 			puts "#{count}) #{message.descriptor.name}, #{'%02X'%message.descriptor.type}"
 			count += 1
 		end

data/lib/px4_log_reader/log_file.rb

@@ -35,17 +35,32 @@ module Px4LogReader
 	module LogFile
 
 		HEADER_MARKER = [0xA3,0x95]
-		HEADER_LENGTH = 3
+		HEADER_LENGTH = HEADER_MARKER.length + 1
 		FORMAT_DESCRIPTOR_TABLE = { FORMAT_MESSAGE.type => FORMAT_MESSAGE }.freeze
 
-		def self.read_descriptors( buffered_io, descriptor_cache=nil )
+		@@debug = false
+
+		def self.enable_debug( enable )
+			@@debug = enable
+		end
+
+		def self.read_descriptors( file, descriptor_cache=nil, &block )
 
 			message_descriptors = {}
 
-			while ( message_descriptor = read_descriptor( buffered_io ) ) do
-				if !message_descriptors.keys.include? message_descriptor.type
-					message_descriptors[ message_descriptor.type ] = message_descriptor
+			loop do
+
+				message_descriptor, file_offset = read_descriptor( file )
+
+				if message_descriptor
+					if !message_descriptors.keys.include? message_descriptor.type
+						message_descriptors[ message_descriptor.type ] = message_descriptor
+						yield message_descriptor if block_given?
+					end
+				else
+					break
 				end
+
 			end
 
 			# If a cache filename was supplied, dump the descriptors to the cache
@@ -56,80 +71,108 @@ module Px4LogReader
 			return message_descriptors
 		end
 
-		def self.read_descriptor( buffered_io, skip_corrupt=true )
+		def self.read_descriptor( file, skip_corrupt=true, &block )
 
 			message_descriptor = nil
+			offset             = nil
 
 			begin
 
-				descriptor_message = read_message( buffered_io, FORMAT_DESCRIPTOR_TABLE )
+				descriptor_message, offset = read_message( file, FORMAT_DESCRIPTOR_TABLE, true, &block )
 
 				if descriptor_message
-
 					message_descriptor = Px4LogReader::MessageDescriptor.new
 					message_descriptor.from_message( descriptor_message )
-
 				end
 
 			rescue Px4LogReader::InvalidDescriptorError => error
 
+				puts "#{error.class}: #{error.message}"
+				puts error.backtrace.join("\n")
+
 				if skip_corrupt
 					retry
 				else
 					raise error
 				end
 
-			rescue StandardError => e
-				puts "#{e.class}: #{e.message}"
-				puts e.backtrace.join("\n")
+			rescue StandardError => error
+				puts "#{error.class}: #{error.message}"
+				puts error.backtrace.join("\n")
 			end
 
-			return message_descriptor
+			return message_descriptor, offset
 		end
 
-		def self.read_message( buffered_io, message_descriptors )
+		def self.read_message( file, message_descriptors, stop_on_no_match = false, &block )
 
 			message = nil
-			while message.nil? do
-				message_type = read_message_header( buffered_io )
+			offset  = nil
+			eof     = false
+
+			while message.nil? && !eof do
+				message_type, offset = read_message_header( file )
+				eof                  = message_type.nil?
 
 				if message_type
 
 					message_descriptor = message_descriptors[ message_type ]
 
+					yield offset if block_given?
+
 					if message_descriptor
-						message_data = buffered_io.read( message_descriptor.length - HEADER_LENGTH )
+
+						message_data = file.read( message_descriptor.length - HEADER_LENGTH )
+						print_data( message_data ) if @@debug
 						message = message_descriptor.unpack_message( message_data )
-					end
 
-				elsif message_type.nil?
-					break
+					elsif stop_on_no_match
+
+						# Seek back to the beginning of the header for the non-
+						# matching message.
+						file.seek( -1 * HEADER_LENGTH, IO::SEEK_CUR )
+						break
+
+					end
 				end
 			end
 
-			return message
+			return message, offset
 		end
 
-		def self.read_message_header( buffered_io )
+		#
+		# Read the next message header from the input stream. Returns the 
+		# message type and current file offset. If no header is found, the
+		# returned message type is nil and the offset is the end of the file.
+		#
+		def self.read_message_header( file )
 			message_type = nil
+			offset       = nil
+			drop_count 	 = 0
 
 			begin
 
-				data = buffered_io.read_nonblock( HEADER_MARKER.length )
+				data   = file.read_nonblock( HEADER_MARKER.length )
+				offset = file.pos
 
 				if data && ( data.length == HEADER_MARKER.length )
 
 					while !data.empty? && message_type.nil? do
 
-						if ( byte = buffered_io.read_nonblock( 1 ) )
+						if ( byte = file.read_nonblock( 1 ) )
 							data << byte
 						end
+						offset = file.pos
 
 						if data.length >= ( HEADER_MARKER.length + 1 )
-							if data.unpack('CCC')[0,2] == HEADER_MARKER
-								message_type = data.unpack('CCC').last & 0xFF
+
+							unpacked_data = data.unpack('C*')
+							
+							if unpacked_data[ 0, HEADER_MARKER.length ] == HEADER_MARKER
+								message_type = unpacked_data.last & 0xFF
 							else
 								data = data[1..-1]
+								drop_count += 1
 							end
 						else
 							data = []
@@ -145,7 +188,7 @@ module Px4LogReader
 				puts error.backtrace.join("\n")
 			end
 
-			return message_type
+			return message_type, offset
 		end
 
 
@@ -155,6 +198,21 @@ module Px4LogReader
 			io.write( message.pack )
 		end
 
+
+		def self.print_data( buffer )
+			text = ''
+			buffer.unpack( 'C*' ).each_with_index do |byte,count|
+				if (count % 16) == 0
+					text << "#{count/16}: "
+				end
+				text << ('%02X'%byte) << ' '
+				if (((count+1) % 16) == 0)
+					text << "\n"
+				end
+			end
+			puts text
+		end
+
 	end
 
 end

data/lib/px4_log_reader/message_descriptor.rb

@@ -34,6 +34,8 @@ module Px4LogReader
 
 	class MessageDescriptor
 
+		@@validation_level = :strict
+
 		attr_reader :name
 		attr_reader :type
 		attr_reader :length
@@ -85,9 +87,16 @@ module Px4LogReader
 
 				fields = fields_string.split(',')
 
-				if fields.length != @format.length
+				if (@@validation_level == :strict) && (fields.length != @format.length)
+					puts "fields = #{fields_string}"
+					puts "format = '#{@format}'"
+					puts "length = #{@length}"
+					puts "type = 0x#{'%02X'% @type}"
 					raise InvalidDescriptorError.new(
 						"Field count must match format length: expected #{@format.length}; found #{fields.length}")
+				elsif (@@validation_level == :lenient) && (fields.length > @format.length)
+					raise InvalidDescriptorError.new(
+						"Field count is greater than format length: expected #{@format.length}; found #{fields.length}")
 				else
 					@field_list = MessageDescriptor.build_field_list( fields )
 				end
@@ -209,7 +218,7 @@ module Px4LogReader
 	FORMAT_MESSAGE = Px4LogReader::MessageDescriptor.new({
 		name: 'FMT',
 		type: 0x80,
-		length: 86,
+		length: 89, # header.size + B(1) + B(1) + n(4) + N(16) + Z(64)
 		format: 'BBnNZ',
 		fields: [ "Type", "Length", "Name", "Format", "Labels" ] }).freeze
 

data/lib/px4_log_reader/progress.rb

@@ -0,0 +1,56 @@
+#
+# Copyright (c) 2016, Robert Glissmann
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+# %% license-end-token %%
+# 
+# Author: Robert.Glissmann@gmail.com (Robert Glissmann)
+# 
+# 
+
+module Px4LogReader
+
+	class Progress
+
+		attr_accessor :file_size
+
+		def initialize( active_file )
+			@active_file = active_file
+
+			active_file.seek( 0, IO::SEEK_END )
+			@file_size = active_file.pos
+			active_file.seek( 0 )
+		end
+
+		def file_offset
+			@active_file.pos
+		end
+
+		def percentage
+			return ( file_offset.to_f / @file_size.to_f )
+		end
+	end
+
+end

data/lib/px4_log_reader/reader.rb

@@ -32,13 +32,20 @@
 
 module Px4LogReader	
 
-	def self.open_common( file, options, &block )
+	# Attach a reader to an existing input stream.
+	#
+	# @param input_stream [IO] Valid input stream
+	# @param options [Hash] Reader options hash
+	# @param block  Optional block
+	#
+	def self.attach( input_stream, options, &block )
 
-		reader = Reader.new( file, options )
+		reader = Reader.new( input_stream, options )
 
 		yield reader if block_given?
 
 		return reader
+		
 	end
 
 	def self.open( filename, options = {}, &block  )
@@ -46,7 +53,7 @@ module Px4LogReader
 		reader = nil
 
 		if File.exist?( filename )
-			reader = self.open_common( File.open( filename, 'r' ), options, &block )
+			reader = self.attach( File.open( filename, 'rb' ), options, &block )
 		end	
 
 		return reader
@@ -57,7 +64,7 @@ module Px4LogReader
 		reader = nil
 
 		if File.exist?( filename )
-			reader = self.open_common( File.open( filename, 'r' ), options, &block )
+			reader = self.attach( File.open( filename, 'rb' ), options, &block )
 		else
 			raise FileNotFoundError.new( filename )
 		end	
@@ -65,11 +72,19 @@ module Px4LogReader
 		return reader
 	end
 
+	# Container to hold the most recent copy of each message type
 	class Context
+
 		attr_reader :messages
+
 		def initialize
-			messages = {}
+			@messages = {}
 		end
+
+		# Query the context for the most recent copy of a message by name
+		#
+		# @param name [String] Message name
+		#
 		def find_by_name( name )
 			named_message = nil
 			@messages.values.each do |message|
@@ -79,40 +94,62 @@ module Px4LogReader
 			end
 			return named_message
 		end
+
+		# Query the context for the most recent copy of a message by type
+		#
+		# @param type [Fixnum]  Message type
+		#
 		def find_by_type( type )
 			return @messages[ type ]
 		end
+
+		# Set the most recent copy of a message by type. Any existing message
+		# is overwritten.
+		#
+		# @param  message [LogMessage]  Message instance
+		#
 		def set( message )
 			@messages[ message.descriptor.type ] = message.dup
 		end
+
 	end
 
-	class Reader   
+	class Reader
+
+		attr_reader :progress
+		attr_reader :context
 
 		def initialize( file, options )
 
 			opts = {
 				cache_filename: '',
-				buffer_size_kb: 10 * 1024
 			}.merge( options )
 
 			@message_descriptors = {}
-			@buffers = LogBufferArray.new
 			@descriptor_cache = nil
 			@context = Context.new
 
 			@log_file = file
-			# @buffers.set_file( @log_file, load_buffers: true )
+			@progress = Progress.new( @log_file )
 
 			@descriptor_cache = MessageDescriptorCache.new( opts[:cache_filename] )
 		end
 
-		def descriptors
+		#
+		# Get the list of descriptors associated with the open PX4 log file.
+		# If a valid descriptor cache was specified at startup, the descriptors
+		# are loaded from the cache. Otherwise, the descriptors are parsed from
+		# the open log.
+		#
+		# @param  [block] optional block is passed each descriptor as it is read
+		# @return descriptors [Array] Array of descriptors
+		#
+		def descriptors( &block )
 			if @log_file && @message_descriptors.empty?
 				if @descriptor_cache && @descriptor_cache.exist?
 					@message_descriptors = @descriptor_cache.read_descriptors
 				else
-					@message_descriptors = LogFile::read_descriptors( @log_file, @descriptor_cache )
+					@message_descriptors = LogFile::read_descriptors( @log_file, @descriptor_cache, &block )
 				end
 
 				@message_descriptors[ FORMAT_MESSAGE.type ] = FORMAT_MESSAGE
@@ -121,6 +158,16 @@ module Px4LogReader
 			return @message_descriptors
 		end
 
+		#
+		# Iterate over all log messages. Embedded message descriptors are skipped.
+		# If a "with" list is supplied, only messages in the list are passed to 
+		# the caller-supplied block. If a "without" list supplied, all messages
+		# except those in the list are passed to the caller-supplied block. The
+		# caller must supply a block.
+		#
+		# @param  options [Hash] options
+		# @param  block   [Block] block takes message as argument
+		#
 		def each_message( options = {}, &block )
 
 			opts ={
@@ -131,7 +178,11 @@ module Px4LogReader
 			opts[:with].map! do |val|
 				if val.class == String
 					descriptor = descriptors.values.find { |desc| desc.name == val }
-					val = descriptor.type
+					if descriptor
+						val = descriptor.type
+					else
+						puts "Failed to find descriptor with name '#{val}'"
+					end
 				end
 			end
 
@@ -151,19 +202,19 @@ module Px4LogReader
 
 				loop do
 
-					message = LogFile::read_message( @log_file, @message_descriptors )
+					message, offset = LogFile::read_message( @log_file, @message_descriptors )
 					break if message.nil?
 
-					# Added message to the set of latest messages.
+					# Add message to the set of latest messages.
 					@context.set( message )
 
 					if opts[:with].empty?
-						if !opts[:without].include?( message.descriptor.name )
-							yield message, @context
+						if !opts[:without].include?( message.descriptor.type )
+							yield message
 						end
 					else
 						if opts[:with].include?( message.descriptor.type )
-							yield message, @context
+							yield message
 						end
 					end
 
@@ -175,17 +226,19 @@ module Px4LogReader
 
 		end
 
-		# def rewind
-		# 	if @log_file
-
-		# 	@log_file.rewind
-		# 	@buffers.load_buffers
-
-		# 	end
-		# end
-
-		# def seek( offset )
-		# end
+		#
+		# Seek to the specified file offset. If the offset is greater than the
+		# file size, seeks to the end of the file.
+		#
+		# @param  offset [Fixnum]  File offset in bytes
+		#
+		def seek( offset )
+			if @log_file
+				seek_offset = offset
+				seek_offset = @progress.file_size if offset > @progress.file_size
+				@log_file.seek( seek_offset, IO::SEEK_SET )
+			end
+		end
 
 	end
 

data/lib/px4_log_reader/version.rb

@@ -1,3 +1,3 @@
 module Px4LogReader
-	VERSION = '0.0.7'
+	VERSION = '1.0.2'
 end

data/lib/px4_log_reader.rb

@@ -37,6 +37,7 @@ require 'px4_log_reader/invalid_descriptor_error'
 require 'px4_log_reader/log_message'
 require 'px4_log_reader/message_descriptor'
 require 'px4_log_reader/log_buffer'
+require 'px4_log_reader/progress'
 require 'px4_log_reader/log_file'
 require 'px4_log_reader/message_descriptor_cache'
 require 'px4_log_reader/reader'

data/test/test_log_file.rb

@@ -41,96 +41,67 @@ class TestLogFile < MiniTest::Test
 	def teardown
 	end
 
-	class MockFileIO
-
-		attr_reader :buffer
-
-		def initialize
-			@buffer = ''
-		end
-
-		def reset
-			@buffer = ''
-		end
-
-		def read( byte_count = nil )
-			data = nil
-
-			if byte_count >= @buffer.size
-				data = @buffer.dup
-				@buffer = ''
-			else
-				data = @buffer[ 0, byte_count ].dup
-				@buffer = @buffer[ byte_count .. -1 ]
-			end
-
-			data
-		end
-
-		def read_nonblock( byte_count = nil )
-			return read( byte_count )
-		end
-
-		def write( data )
-			@buffer << data
-		end
-
-	end
-
 	def test_read_header
 
 		# First, test that read_message_header returns null if the file is exhausted
 		# without finding a message header.
-		mock_io = MockFileIO.new
-		mock_io.write( rand_data( 256 ).pack('C*') )
-
-		assert_nil Px4LogReader::LogFile.read_message_header( mock_io )
-		assert_equal true, mock_io.buffer.empty?
+		mock_io( rand_data( 256 ).pack('C*') ) do |writer,reader|
+			assert_equal [ nil, 256 ], Px4LogReader::LogFile.read_message_header( reader )
+			assert_equal 256, reader.pos
+		end
 
 
 		# Insert a message header with type = 0x80 into the middle of the data.
-		mock_io = MockFileIO.new
-
 		test_data = rand_data( 256 )
 		test_data.concat( Px4LogReader::LogFile::HEADER_MARKER )
 		test_data.concat( [ Px4LogReader::FORMAT_MESSAGE.type ] )
-		test_data.concat( rand_data( 256 ) )
-		mock_io.write( test_data.pack('C*') )
+		test_data.concat( rand_data( 256 ) )		
+		mock_io( test_data.pack('C*') ) do |writer,reader|
 
-		assert_equal Px4LogReader::FORMAT_MESSAGE.type, Px4LogReader::LogFile.read_message_header( mock_io )
-		assert_equal 256, mock_io.buffer.size
+			message_type, offset = Px4LogReader::LogFile.read_message_header( reader )
 
-		assert_nil Px4LogReader::LogFile.read_message_header( mock_io )
-		assert_equal true, mock_io.buffer.empty?
+			assert_equal Px4LogReader::FORMAT_MESSAGE.type, message_type
+			assert_equal 256 + Px4LogReader::LogFile::HEADER_LENGTH, offset
 
+			message_type, offset = Px4LogReader::LogFile.read_message_header( reader )
+			assert_nil message_type
+			assert_equal true, reader.eof?
+			assert_equal test_data.size, offset
+
+		end
 
-		# Test with a buffer that ends in a message header sync pattern.
-		mock_io = MockFileIO.new
 
+		# Test with a buffer that ends in a message header sync pattern.
 		test_data = rand_data( 64 )
 		test_data.concat( Px4LogReader::LogFile::HEADER_MARKER )
-		mock_io.write( test_data.pack('C*') )
+		mock_io( test_data.pack('C*') ) do |writer,reader|
 
-		assert_nil Px4LogReader::LogFile.read_message_header( mock_io )
-		assert_equal true, mock_io.buffer.empty?
+			message_type, offset = Px4LogReader::LogFile.read_message_header( reader )
+			assert_nil message_type
+			assert_equal true, reader.eof?
+			assert_equal test_data.size, offset
+
+		end
 		
 	end
 
 	def test_write_message
 
-		mock_io = MockFileIO.new
-
 		fields = [ 0x24, 32, 'test', 'IIbMh', 'id,counts,flag,length,ord' ]
 
 		message = Px4LogReader::LogMessage.new(
 			Px4LogReader::FORMAT_MESSAGE,
 			fields )
 
-		Px4LogReader::LogFile.write_message( mock_io, message )
+		mock_io do |writer,reader|
+			Px4LogReader::LogFile.write_message( writer, message )
 
-		expected_length = Px4LogReader::FORMAT_MESSAGE.length + Px4LogReader::LogFile::HEADER_MARKER.length + 1
-		assert_equal expected_length, mock_io.buffer.length 
-		assert_equal [ 0xA3, 0x95, 0x80 ], mock_io.buffer[0,3].unpack('C*')
+			expected_length = Px4LogReader::FORMAT_MESSAGE.length
+			assert_equal expected_length, writer.pos
+
+			header = reader.read( 3 )
+			assert_equal [ 0xA3, 0x95, 0x80 ], header.unpack('C*')
+		end
 
 	end
 
@@ -155,4 +126,34 @@ class TestLogFile < MiniTest::Test
 		return test_data
 	end
 
+	def mock_io( buffer = nil )
+
+		temp_filename = File.join( 'test', 'temp_test_data', 'mock_io.dat' )
+		unless Dir.exist?( File.dirname( temp_filename ) )
+			FileUtils.mkdir( File.dirname( temp_filename ) )
+		end
+
+		# Create the file.
+		FileUtils.touch( temp_filename )
+
+		# Open the file for writing and reading and writing.
+		writer = File.open( temp_filename, 'wb' )
+		if buffer
+			writer.write( buffer )
+			writer.flush
+		end
+
+		reader = File.open( temp_filename, 'rb' )
+
+		yield writer, reader if block_given?
+
+		reader.close
+		writer.close
+
+		if Dir.exist?( File.dirname( temp_filename ) )
+			FileUtils.rm_rf( File.dirname( temp_filename ) )
+		end
+
+	end
+
 end

data/test/test_reader.rb

@@ -84,36 +84,56 @@ class TestReader < MiniTest::Test
 			# The log file associated with this test case contains the following
 			# messages in the specified order. Validate the order and context.
 			#
-			# 1) TIME
-			# 2) STAT
-			# 3) IMU
-			# 4) SENS
-			# 5) IMU1
-			# 6) VTOL
-			# 7) GPS
+			# 1: LPOS
+			# 2: GPOS
+			# 3: BATT
+			# 4: PWR
+			# 5: EST0
+			# 6: EST1
+			# 7: EST2
+			# 8: EST3
+			# 9: CTS
+			# 10: ATT
+			# 11: TIME
+			# 12: IMU
+			# 13: SENS
+			# 14: IMU1
+			# 15: ATSP
+			# 16: ARSP
+			# 17: OUT0
+			# 18: ATTC
 			#
 			index = 0
-			expected_message_names = ['TIME','STAT','IMU','SENS','IMU1','VTOL','GPS']
-			expected_message_types = [0x81,0x0A,0x04,0x05,0x16,0x2B,0x08]
+			expected_messages = [
+				['LPOS',0x06],
+				['GPOS',0x10],
+				['BATT',0x14],
+				['PWR',0x18],
+				['EST0',0x20],
+				['EST1',0x21],
+				['EST2',0x22]]
 
-			reader.each_message do |message,context|
+			reader.each_message do |message|
 
-				expected_name = expected_message_names[ index ]
-				expected_type = expected_message_types[ index ]
+				# puts "#{index+1}: #{message.descriptor.name}, #{'%02X'%message.descriptor.type}"
+				break if index >= expected_messages.size
+
+				expected_name = expected_messages[ index ][0]
+				expected_type = expected_messages[ index ][1]
 
 				assert_equal expected_name, message.descriptor.name
 				assert_equal expected_type, message.descriptor.type
 
-				context_message = context.find_by_name( expected_name )
+				context_message = reader.context.find_by_name( expected_name )
 				refute_nil context_message
 				assert_equal expected_name, context_message.descriptor.name
 
-				context_message = context.find_by_type( expected_type )
+				context_message = reader.context.find_by_type( expected_type )
 				refute_nil context_message
 				assert_equal expected_type, context_message.descriptor.type
 
 				index += 1
-				assert_equal index, context.messages.size
+				assert_equal index, reader.context.messages.size
 
 			end
 
@@ -133,40 +153,36 @@ class TestReader < MiniTest::Test
 
 			log_file_opened = true
 
-			# The log file associated with this test case contains the following
-			# messages in the specified order. Validate the order and context.
-			#
-			# 1) TIME
-			# 2) STAT
-			# 3) IMU
-			# 4) SENS
-			# 5) IMU1
-			# 6) VTOL
-			# 7) GPS
-			#
+			# See test_reader for the un-filtered list of messages. This test
+			# expects the same list, minus the GPOS and EST1 messages.
 
 			index = 0
-			expected_message_names = ['TIME','IMU','SENS','VTOL','GPS']
-			expected_message_types = [0x81,0x04,0x05,0x2B,0x08]
+			expected_messages = [
+				['LPOS',0x06],
+				['BATT',0x14],
+				['PWR',0x18],
+				['EST0',0x20],
+				['EST2',0x22]]
+
+			reader.each_message( { without: ['GPOS','EST1'] } ) do |message|
 
-			reader.each_message( { without: ['STAT','IMU1'] } ) do |message,context|
+				break if index >= expected_messages.size
 
-				expected_name = expected_message_names[ index ]
-				expected_type = expected_message_types[ index ]
+				expected_name = expected_messages[ index ][0]
+				expected_type = expected_messages[ index ][1]
 
 				assert_equal expected_name, message.descriptor.name
 				assert_equal expected_type, message.descriptor.type
 
-				context_message = context.find_by_name( expected_name )
+				context_message = reader.context.find_by_name( expected_name )
 				refute_nil context_message
 				assert_equal expected_name, context_message.descriptor.name
 
-				context_message = context.find_by_type( expected_type )
+				context_message = reader.context.find_by_type( expected_type )
 				refute_nil context_message
 				assert_equal expected_type, context_message.descriptor.type
 
 				index += 1
-				assert_equal index, context.messages.size
 
 			end
 
@@ -184,40 +200,33 @@ class TestReader < MiniTest::Test
 
 			log_file_opened = true
 
-			# The log file associated with this test case contains the following
-			# messages in the specified order. Validate the order and context.
-			#
-			# 1) TIME
-			# 2) STAT
-			# 3) IMU
-			# 4) SENS
-			# 5) IMU1
-			# 6) VTOL
-			# 7) GPS
-			#
+			# See test_reader for the un-filtered list of messages. This test
+			# expects just the GPOS and PWR messages.
 
 			index = 0
-			expected_message_names = ['TIME','SENS']
-			expected_message_types = [0x81,0x05]
+			expected_messages = [
+				['GPOS',0x10],
+				['PWR',0x18]]
+
+			reader.each_message( { with: ['GPOS','PWR'] } ) do |message|
 
-			reader.each_message( { with: ['TIME','SENS'] } ) do |message,context|
+				break if index >= expected_messages.size
 
-				expected_name = expected_message_names[ index ]
-				expected_type = expected_message_types[ index ]
+				expected_name = expected_messages[ index ][0]
+				expected_type = expected_messages[ index ][1]
 
 				assert_equal expected_name, message.descriptor.name
 				assert_equal expected_type, message.descriptor.type
 
-				context_message = context.find_by_name( expected_name )
+				context_message = reader.context.find_by_name( expected_name )
 				refute_nil context_message
 				assert_equal expected_name, context_message.descriptor.name
 
-				context_message = context.find_by_type( expected_type )
+				context_message = reader.context.find_by_type( expected_type )
 				refute_nil context_message
 				assert_equal expected_type, context_message.descriptor.type
 
 				index += 1
-				assert_equal index, context.messages.size
 
 			end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: px4_log_reader
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 1.0.2
 platform: ruby
 authors:
 - Robert Glissmann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-11 00:00:00.000000000 Z
+date: 2016-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -46,6 +46,7 @@ files:
 - lib/px4_log_reader/log_message.rb
 - lib/px4_log_reader/message_descriptor.rb
 - lib/px4_log_reader/message_descriptor_cache.rb
+- lib/px4_log_reader/progress.rb
 - lib/px4_log_reader/reader.rb
 - lib/px4_log_reader/version.rb
 - px4_log_reader.gemspec