module Px4LogReader::LogFile

Constants

FORMAT_DESCRIPTOR_TABLE
HEADER_LENGTH
HEADER_MARKER

Public Class Methods

enable_debug( enable ) click to toggle source
# File lib/px4_log_reader/log_file.rb, line 43
def self.enable_debug( enable )
        @@debug = enable
end
print_data( buffer ) click to toggle source
read_descriptor( file, skip_corrupt=true, &block ) click to toggle source
# File lib/px4_log_reader/log_file.rb, line 74
def self.read_descriptor( file, skip_corrupt=true, &block )

        message_descriptor = nil
        offset             = nil

        begin

                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 => error
                puts "#{error.class}: #{error.message}"
                puts error.backtrace.join("\n")
        end

        return message_descriptor, offset
end
read_descriptors( file, descriptor_cache=nil ) { |message_descriptor| ... } click to toggle source
# File lib/px4_log_reader/log_file.rb, line 47
def self.read_descriptors( file, descriptor_cache=nil, &block )

        message_descriptors = {}

        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
        if descriptor_cache
                descriptor_cache.write_descriptors( message_descriptors )
        end

        return message_descriptors
end
read_message( file, message_descriptors, stop_on_no_match = false ) { |offset| ... } click to toggle source
# File lib/px4_log_reader/log_file.rb, line 107
def self.read_message( file, message_descriptors, stop_on_no_match = false, &block )

        message = nil
        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 = file.read( message_descriptor.length - HEADER_LENGTH )
                                print_data( message_data ) if @@debug
                                message = message_descriptor.unpack_message( message_data )

                        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, offset
end
read_message_header( file ) click to toggle source

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.

# File lib/px4_log_reader/log_file.rb, line 148
def self.read_message_header( file )
        message_type = nil
        offset       = nil
        drop_count    = 0

        begin

                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 = file.read_nonblock( 1 ) )
                                        data << byte
                                end
                                offset = file.pos

                                if data.length >= ( HEADER_MARKER.length + 1 )

                                        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 = []
                                end

                        end
                end

        rescue EOFError => error
                # Nothing to do.
        rescue StandardError => error
                puts error.message
                puts error.backtrace.join("\n")
        end

        return message_type, offset
end
write_message( io, message ) click to toggle source
# File lib/px4_log_reader/log_file.rb, line 195
def self.write_message( io, message )
        io.write( HEADER_MARKER.pack('CC') )
        io.write( [ message.descriptor.type ].pack('C') )
        io.write( message.pack )
end