elia 1.1.0 → 1.2.0

data/VERSION

@@ -1 +1 @@
-1.1.0
+1.2.0

data/lib/bit_fields.rb

@@ -82,7 +82,6 @@ module BitFields
   # 
   def field name, unpack_recipe = 'C', &bit_fields_definitions_block
     include InstanceMethods # when used we include instance methods
-    logger.debug { self.ancestors.inspect }
     
     # Setup class "instance" vars
     @fields        ||= []
@@ -95,7 +94,6 @@ module BitFields
     
     # Define the attribute reader
     class_eval "def #{name}; self.attributes[#{name.inspect}]; end;", __FILE__, __LINE__
-    # define_method(name) { self.fields[name] }
     
     # There's a bit-structure too?
     if block_given?
@@ -103,7 +101,7 @@ module BitFields
       
       bit_fields_definitions_block.call
       
-      @bit_fields[name] = @_current_bit_fields
+      @bit_fields[name] = @_current_bit_fields.reverse
       @_current_bit_fields = nil
     end
   end
@@ -118,7 +116,7 @@ module BitFields
     raise "'bit_field' can be used only inside a 'field' block." if @_current_bit_fields.nil?
     
     # Register the bit field definition
-    @_current_bit_fields << [name, width]
+    @_current_bit_fields << [name, width, bit_mask(width)]
     
     # Define the attribute reader
     class_eval "def #{name};  self.attributes[#{name.inspect}];      end\n", __FILE__, __LINE__
@@ -134,9 +132,14 @@ module BitFields
       end
     end
     
-    logger.debug { @_current_bit_fields.inspect }
   end
   
+  def bit_mask size
+    2 ** size - 1
+  end
+  
+  
+  
   
   module InstanceMethods
     # Contains the raw string
@@ -160,10 +163,10 @@ module BitFields
     
     private
     
-    def eat_right_bits original_value, bits_number
+    def eat_right_bits original_value, bits_number, bit_mask
       # Filter the original value with the 
       # proper bitmask to get the rightmost bits
-      new_value = original_value & bit_mask(bits_number)
+      new_value = original_value & bit_mask
       
       # Eat those rightmost bits 
       # wich we have just consumed
@@ -178,40 +181,27 @@ module BitFields
       @raw = raw
       
       # Setup
-      unpack_recipe = self.class.unpack_recipe
-      logger.debug "Unpacking #{@raw.inspect} with #{unpack_recipe.inspect}"
-      @unpacked     = @raw.unpack(unpack_recipe)
+      @unpacked     = @raw.unpack( self.class.unpack_recipe )
       @attributes ||= {}
       
-      logger.debug { "Parsing #{@raw.inspect} with fields #{self.class.fields.inspect}" }
       self.class.fields.each_with_index do |name, position|
-        logger.debug { "Parsing field #{name.inspect}" }
         
-        attributes[name] = @unpacked[position]
+        @attributes[name] = @unpacked[position]
         
         # We must extract bits from end since 
         # ruby doesn't have types (and fixed lengths)
-        if bit_definitions = self.class.bit_fields[name]
-          logger.debug { "Parsing value #{attributes[name]} with bit fields #{bit_definitions.inspect}" }
+        if bit_fields = self.class.bit_fields[name]
         
           bit_value = attributes[name]
-          bit_definitions.reverse.each do |bit_field|
-            logger.debug "Parsing bit field: #{bit_field.inspect} current value: #{bit_value} (#{bit_value.to_s 2})"
-            bit_name, bit_size = *bit_field
-            attributes[bit_name], bit_value = eat_right_bits(bit_value, bit_size)
-          
-            logger.debug {
-              "#{bit_name}: #{attributes[bit_name]} 0b#{attributes[bit_name].to_s(2).rjust(16, '0')}"
-            }
+          bit_fields.each do |(bit_name, bits_number, bit_mask)|
+            # @attributes[bit_name], bit_value = eat_right_bits(bit_value, bits_number, bit_mask)
+            # logger.debug "#{bit_name.to_s.rjust(20)}: #{bit_value.to_s(2).rjust(40)} & #{bit_mask.to_s(2).rjust(20)} = #{(bit_value & bit_mask).to_s(2).rjust(20)}"
+            
+            @attributes[bit_name]  = bit_value & bit_mask
+            bit_value = bit_value >> bits_number
           end
         end
       end
-      
-      @parsed = true
-    end
-    
-    def bit_mask size
-      2 ** size - 1
     end
     
     def to_s

data/lib/ccsds.rb

@@ -0,0 +1,167 @@
+# This links the logger method to Rails.logger
+require 'world_logger'
+require 'io_string'
+require 'bit_fields'
+require 'active_support'
+require 'string_nibbles'
+
+module CCSDS
+  
+  class Packet
+    
+    # HEADER
+    
+    class Header
+      extend BitFields
+      field :packet_identification,    'n' do
+        bit_field :version,             3
+        bit_field :type,                1
+        bit_field :data_header,         1
+        bit_field :apid,               11
+      end
+      field :packet_sequence_control,  'n' do
+        bit_field :segmentation_flags,  2
+        bit_field :ssc,                14
+      end
+      field :packet_length, 'n'
+      def data_size
+        packet_length + 1
+      end
+      
+      SIZE = 6 # bytes
+    end
+    
+    
+    
+    
+    # DATA HEADER
+    
+    # Data Header is different for each project, 
+    # so we assume it isn't present but we provide builtin support for it.
+    # 
+    # If the header has 
+    # 
+    # Example:
+    # 
+    #   class DataHeader
+    #     extend BitFields
+    #     field :unknown
+    #     SIZE = 1 # bytes
+    #   end
+    # 
+    
+    
+    
+    
+    # ERRORS
+    
+    class DataError < StandardError
+      attr_reader :packet
+      def initialize message, packet
+        @packet = packet
+        super(message)
+      end
+    end
+    
+    
+    
+    
+    # ATTRIBUTES
+    
+    attr_reader :data, :header, :data_header
+    
+    # Delegate unknown methods to packet header.
+    def method_missing name, *args
+      if header.respond_to? name
+        header.send name, *args
+      else
+        super
+      end
+    end
+    
+    def raw
+      header.raw + data
+    end
+    
+    def data= data
+      raise "Data already filled: #{@data.inspect}" unless @data.blank?
+      @data = data
+    end
+    
+    
+    
+    
+    # INITAILIZATION
+    
+    def initialize raw, validate_now = true
+      raise DataError.new("Received no RAW data to build the CCSDS Packet: #{raw.inspect}", self) if raw.blank?
+      
+      # logger.debug {  "Parsing CCSDS header" }
+      # @header      = Header.new(raw[0...Header::SIZE]) # Packet Header
+      @header      = Header.new(raw) # Packet Header
+      @data        = raw[Header::SIZE..-1]             # Packet Payload
+      validate! if validate_now
+      
+      if defined? DataHeader
+        raise "You should define CCSDS::Packet::DataHeader class" unless defined? DataHeader
+        
+        @data_header = DataHeader.new( @data[0 ... DataHeader::SIZE] )
+        
+        # Update the data contents excluding the Data Header
+        @data        = @data[DataHeader::SIZE ..  -1]
+      end
+    end
+    
+    
+    
+    
+    # VALIDATION
+    
+    def validate
+      @errors = []
+      if data.size != header.data_size
+        @errors <<  "Available data (#{data.size} bytes) is different than "+
+                    "specified by the CCSDS packet header (#{header.data_size} bytes)."+
+                    "\nHeader #{header.raw.nibbles.inspect} dump: #{header.inspect}"
+      end
+    end
+    
+    def validate!
+      validate
+      raise DataError.new(@errors.first, self) unless @errors.blank?
+    end
+    
+    def valid?
+      validate
+      return @errors.empty?
+    end
+    
+    
+    
+    
+    # PACKET EXTRACTION
+    
+    class << self
+      include IndifferentReader
+      
+      def extract_packet io_or_string, *errors_to_rescue
+        begin
+          packet      = new( io_or_string.io.read(Header::SIZE), false )
+          packet.data =      io_or_string.io.read(packet.data_size)
+          packet.validate!
+          return packet
+        rescue *errors_to_rescue
+          logger.info "Rescued error: (#{$!.class}) #{$!.to_s}"
+          return nil # just go on...
+        end
+      end
+    
+      def each_packet io_or_string, *errors_to_rescue
+        while packet = extract_packet(io_or_string, *errors_to_rescue)
+          yield packet
+        end
+      end
+    end
+    
+  end
+end

data/lib/ccsds/cuc.rb

@@ -0,0 +1,29 @@
+# CCSDS Unsegmented Time Code
+
+
+module CCSDS
+  module CUC
+    
+    # def cuc_time time
+    #   secs, msecs = time.to_f.divmod(1) # split integer and fractional parts
+    #   msecs = (msecs * 256).to_i
+    #   [secs, msecs].pack('xN C') # cut off first byte: "@" skips a byte
+    # end
+    # 
+    # def self.cuc_time_parse cuc
+    #   secs, msecs = (0.chr + cuc).unpack('xN C')
+    #   time = secs + (msecs / 256.0)
+    #   Time.at(time)
+    # end
+    
+    class << self
+      # coarse are seconds
+      # fine are milliseconds muliplied for 256
+      def parse coarse, fine
+        secs, usecs = coarse, ((fine * 15.0) / 1_000_000.0)
+        Time.at(secs + usecs)
+      end
+    end
+    
+  end
+end

data/lib/file_with_read_buffer.rb

@@ -0,0 +1,29 @@
+module FileWithBufferedRead
+  require 'stringio'
+  
+  READ_BUFFER_SIZE = 1 << 22
+  
+  def buffered_read size
+    output = read_buffer.read(size)
+    until output.size == size or self.eof?
+      output << read_buffer.read(size - output.size)
+    end
+    return output
+  end
+  
+  private
+  def buffer_left
+    read_buffer.size - read_buffer.pos
+  end
+  
+  def read_buffer
+    if @read_buffer.nil? or @read_buffer.eof?
+      # logger.debug{ "Buffering #{READ_BUFFER_SIZE} from #{self.inspect} current position: #{self.pos}" }
+      @read_buffer = StringIO.new(read(READ_BUFFER_SIZE))
+      # logger.debug{ "Buffered #{@read_buffer.size}, EOF:#{self.eof?} current position: #{self.pos}" }
+      @buffer_left = @read_buffer.size
+    end
+    @read_buffer
+  end
+  
+end

data/lib/indifferent_reader.rb

@@ -0,0 +1,36 @@
+module IndifferentReader
+  
+  class DataError < StandardError
+    attr_reader :data
+    def initialize message, data
+      @data = data
+      super(message)
+    end
+  end
+  
+  module IOString
+    require 'stringio'
+    def read size
+      @string_io ||= StringIO.new(self)
+      @string_io.read(size)
+    end
+  end
+  
+  def read_from io_or_string, size
+    if io_or_string.kind_of? String
+      io_or_string.extend IOString
+    end
+    
+    if io_or_string.respond_to? :read
+      result = io_or_string.read(size)
+      
+    elsif io_or_string.nil?
+      raise DataError.new("Perhaps DATA has ended? check your FHP.", io_or_string)
+    else
+      raise "Unknown source: #{io_or_string.inspect}"
+    end
+    return result
+  end
+  
+  extend self
+end

data/lib/io_string.rb

@@ -0,0 +1,29 @@
+require 'stringio'
+
+module IOString
+  
+  module String
+    def io
+      @__io ||= StringIO.new(self)
+    end
+  end
+  
+  module IO
+    def io
+      self
+    end
+  end
+  
+end
+
+class String
+  include IOString::String
+end
+
+class StringIO
+  include IOString::IO
+end
+
+class IO
+  include IOString::IO
+end

data/lib/sass_support.rb

@@ -0,0 +1,3 @@
+require 'haml'
+
+Sass::Plugin.options[:loadpaths] << File.dirname(__FILE__) + '/sass_support'

data/lib/sass_support/_border_radius.sass

@@ -0,0 +1,61 @@
+// Border-radius helps to make it easier to round the corners of your HTML elements
+// Sample Usage:
+// #container
+//   +border-radius("5px")
+
+// All corners
+=border-radius(!radius)
+  border-radius = !radius
+  -moz-border-radius = !radius
+  -webkit-border-radius = !radius
+
+// Top Right
+=border-radius-top-right(!radius)
+  +border-radius-top-right(!radius)
+// Bottom Right
+=border-radius-bottom-right(!radius)
+  +border-radius-bottom-right(!radius)
+// Bottom Left
+=border-radius-bottom-left(!radius)
+  +border-radius-bottom-left(!radius)
+// Top Left
+=border-radius-top-left(!radius)
+  +border-radius-top-left(!radius)
+// Top
+=border-radius-top(!radius)
+  +border-radius-top-left(!radius)
+  +border-radius-top-right(!radius)
+// Right
+=border-radius-right(!radius)
+  +border-radius-top-right(!radius)
+  +border-radius-bottom-right(!radius)
+// Bottom
+=border-radius-bottom(!radius)
+  +border-radius-bottom-right(!radius)
+  +border-radius-bottom-left(!radius)
+// Left
+=border-radius-left(!radius)
+  +border-radius-top-left(!radius)
+  +border-radius-bottom-left(!radius)
+
+// Let's setup the rules so we don't have to repeat ourselves
+// These are mixins for this mixin and are re-used above
+=border-radius-top-right(!radius)
+  border-top-right-radius = !radius
+  -moz-border-radius-topright = !radius
+  -webkit-border-top-right-radius = !radius
+
+=border-radius-bottom-right(!radius)
+  border-bottom-right-radius = !radius
+  -moz-border-radius-bottomright = !radius
+  -webkit-border-bottom-right-radius = !radius
+
+=border-radius-bottom-left(!radius)
+  border-bottom-left-radius = !radius
+  -moz-border-radius-bottomleft = !radius
+  -webkit-border-bottom-left-radius = !radius
+
+=border-radius-top-left(!radius)
+  border-top-left-radius = !radius
+  -moz-border-radius-topleft = !radius
+  -webkit-border-top-left-radius = !radius

data/lib/sass_support/_glider.sass

@@ -0,0 +1,19 @@
+.imgLink
+  cursor: pointer
+
+
+=glider_container(!width=600px, !height=400px)
+  width= !width
+  height= !height
+  overflow: hidden
+  
+=glider_sections_container
+  width: 20000px
+  
+=glider_section(!width=600px, !height=400px)
+  width= !width
+  - unless !height == 'auto'
+    height: !height - 30px
+  overflow: hidden
+  float: left
+  padding: 10px

data/lib/slapp.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env arch -i386 ruby
+# coding: utf-8
+
+
+# A WxRuby Shoes-like DSL
+# 
+#   #!/usr/bin/env arch -i386 ruby
+#   require 'rubygems'
+#   require 'slapp'
+#   
+#   Slapp.app {
+#     frame :title => "Wow!" do
+#       button :start_stop, :caption => "start/stop"
+#     end
+#   }
+# 
+# 
+# 
+# OSX Snow Leopard users see: http://exceptionisarule.blogspot.com/2009/11/building-wxruby-201-on-snow-leopard.html
+# 
+module Slapp
+  require 'wx'
+  module Sugar
+    include Wx
+    def frame options = {}, &block
+      elements[:frame] = Frame.new(nil, -1, options[:title])
+      block.call
+      elements[:frame].show
+      return elements[:frame]
+    end
+  
+    def elements
+      @elements ||= {}
+    end
+  
+    def button name, options = {}
+      elements[name] ||= Button.new elements[:frame], -1, options[:caption]
+    end
+  end
+  
+  def self.app &block
+    Wx::App.app &block
+    Wx::App.run
+  end
+end
+
+class Wx::App
+  include Slapp::Sugar
+  def on_init
+    self.instance_eval &self.class.app
+  end
+  def self.app &block
+    if block_given?
+    then @on_init_proc = block
+    else @on_init_proc
+    end
+  end
+  def run
+    new.main_loop
+  end
+end

data/lib/space_wire.rb

@@ -0,0 +1,142 @@
+require 'bit_fields'
+require 'indifferent_reader'
+require 'file_with_read_buffer'
+
+module SpaceWire
+  
+  
+  # Reads the index file generated by the SpaceWire FEE 
+  # along with the binary file.
+  class Index
+    
+    # Each line of the Index is 9 bytes: 
+    # * 1 for en of packet character
+    # * 8 indicating the byte position of the end of the 
+    #   packet inside of the binady file
+    class Record
+      extend BitFields
+      field :error_control, 'c'
+      field :end_position,  'Q'
+      
+      alias bad_end_position end_position
+      def end_position
+        bad_end_position + 1
+      end
+      
+      SIZE = 9
+    end
+    
+    include IndifferentReader
+    attr_reader :records
+    
+    def records
+      if @records.nil?
+        @records = []
+        each do |record|
+          @records << record
+        end
+      end
+      @records
+    end
+    
+    # Takes a string, string io, or any io
+    def initialize(io_or_string)
+      @source = io_or_string
+    end
+    
+    def each
+      if @records.nil?
+        @records = []
+        
+        while line = @source.io.read(Record::SIZE)
+          record = Record.new(line)
+          @records << record
+          yield record if block_given?
+        end
+      else
+        block_given? ? records.each(&block) : records
+      end
+    end
+  end
+  
+  
+  class Data
+    attr_reader :file, :index
+    
+    def initialize file_path, index_path
+      @file_path, @index_path = file_path, index_path
+      
+      @file = File.open(@file_path)
+      @file.extend FileWithBufferedRead
+      
+      @index = Index.new File.read(@index_path)
+    end
+    
+    def each_packet
+      previous_end_position = 0
+      index.each do |packet_index|
+        packet_size = packet_index.end_position - previous_end_position
+        
+        packet = file.buffered_read(packet_size).extend(Packet)
+        # packet = extract_packet(previous_end_position, packet_index.end_position)
+        yield packet
+        previous_end_position = packet_index.end_position
+      end
+    end
+    
+    def packets
+      if @packets.nil?
+        @packets = []
+        each_packet { |packet| @packets << packet }
+      end
+      @packets
+    end
+    
+    def extract_packet start_position, end_position
+      previous_file_position = file.pos
+      file.seek start_position
+      packet = file.read(end_position - start_position)
+      file.seek previous_file_position
+      
+      packet.extend Packet
+      packet.header_size = 4
+      packet
+    end
+    
+    def [] position
+      if position == 0
+      then start_position = 0
+      else start_position = index.records[position - 1].end_position
+      end
+      
+      end_position   = index.records[ position ].end_position
+      extract_packet(start_position, end_position)
+    end
+  end
+  
+  
+  module Packet
+    HEADER_SIZE = 4
+    def raw
+      self
+    end
+    
+    def header
+      self[0 ... HEADER_SIZE]
+    end
+    
+    def data
+      self[HEADER_SIZE ...-1]
+    end
+    
+    def end_of_packet_char
+      self[-1].chr
+    end
+  end
+  
+  
+  
+  def self.rote_quadrate
+    raise "È una doccia fredda!"
+  end
+end

data/spec/lib/bit_fields_spec.rb

@@ -29,6 +29,8 @@ describe BitFields do
     @object.char_value.should == 23
     @object.secondary_header_flag.should == 0b1
     @object.sync_flag.should == 0b0
+    @object.packet_order.should == 0b1
+    @object.segment_length_id.should == 0b00
     @object.first_header_pointer.should == 0b111_11111111
   end
   

data/spec/lib/ccsds_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'ccsds'
+
+describe CCSDS do
+  it 'should be tested' do
+    fail
+  end
+end
+

data/spec/lib/indifferent_reader_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'indifferent_reader'
+describe IndifferentReader do
+  include IndifferentReader
+  
+  it 'should read a string' do
+    s = "asdf" * 200
+    
+    pos = 0
+    [1,2,3,4,5,6,7].each do |n|
+      read_from(s, n).should == s[pos...(pos+n)]
+      pos += n
+    end
+  end
+  
+  it 'should read from IO' do
+    fail
+  end
+  
+  it 'should read from StringIO' do
+    fail
+  end
+end
+

data/spec/lib/space_wire_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'space_wire'
+require 'stringio'
+
+describe SpaceWire do
+  before :all do
+    base_dir = File.dirname(__FILE__) + '/space_wire/'
+    
+    @index_path = base_dir + '/index.bin'
+    @file_path  = base_dir + '/data.bin'
+  end
+  
+  it 'should read SpaceWire indexes' do
+    last_end_position = 0
+    index = SpaceWire::Index.new(File.read(@index_path))
+    index.records.size.should == 100
+    index.records.each do |record|
+      record.end_position.should == last_end_position + 4117
+      record.error_control.should == 0
+      last_end_position = record.end_position
+    end
+    
+    File.open(@index_path,'r') do |file|
+      last_end_position = 0
+      while index = file.read(9)
+        end_char, end_position = index.unpack('cQ')
+        end_position.should == last_end_position + 4117
+        end_char.should == 0
+        last_end_position = end_position
+      end
+    end
+  end
+  
+  it 'should read packets from data file' do
+    space_wire_data = SpaceWire::Data.new(@file_path, @index_path)
+    
+    packets = []
+    space_wire_data.each_packet do |packet|
+      packet.end_of_packet_char.should == 0.chr
+      packet.size.should == 4117
+      packet.header_size.should == 4
+      packet.header.size.should == packet.header_size
+      packets << packet
+    end
+    packets.size.should == 100
+    space_wire_data.packets.should == packets
+    
+    100.times { |n|
+      space_wire_data[n].should == packets[n]
+    }
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: elia
 version: !ruby/object:Gem::Version 
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Elia Schito
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-01 00:00:00 +01:00
+date: 2009-12-11 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,15 +37,30 @@ files:
 - Rakefile
 - VERSION
 - lib/bit_fields.rb
+- lib/ccsds.rb
+- lib/ccsds/cuc.rb
 - lib/elia.rb
+- lib/file_with_read_buffer.rb
+- lib/indifferent_reader.rb
+- lib/io_string.rb
 - lib/path_operator.rb
 - lib/process_extensions.rb
+- lib/sass_support.rb
+- lib/sass_support/_border_radius.sass
+- lib/sass_support/_glider.sass
+- lib/slapp.rb
+- lib/space_wire.rb
 - lib/string_nibbles.rb
 - lib/world_logger.rb
 - spec/lib/bit_fields_spec.rb
+- spec/lib/ccsds_spec.rb
 - spec/lib/elia_spec.rb
+- spec/lib/indifferent_reader_spec.rb
 - spec/lib/path_operator_spec.rb
 - spec/lib/process_extensions_spec.rb
+- spec/lib/space_wire/data.bin
+- spec/lib/space_wire/index.bin
+- spec/lib/space_wire_spec.rb
 - spec/lib/string_nibbles_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -79,8 +94,11 @@ specification_version: 3
 summary: Elia Schito's utility belt
 test_files: 
 - spec/lib/bit_fields_spec.rb
+- spec/lib/ccsds_spec.rb
 - spec/lib/elia_spec.rb
+- spec/lib/indifferent_reader_spec.rb
 - spec/lib/path_operator_spec.rb
 - spec/lib/process_extensions_spec.rb
+- spec/lib/space_wire_spec.rb
 - spec/lib/string_nibbles_spec.rb
 - spec/spec_helper.rb