enginevib 0.1.0

data/dtrace/script.d

@@ -0,0 +1,14 @@
+ruby*:::object-create
+{
+  @objects[copyinstr(arg0)] = count();
+}
+
+ruby*:::method-entry
+{
+  @objects[copyinstr(arg1)] = count();
+}
+
+ruby*:::cmethod-entry
+{
+  @objects[copyinstr(arg1)] = count();
+}

data/enginevib.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'enginevib/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "enginevib"
+  spec.version       = Enginevib::VERSION
+  spec.authors       = ["Eduardo Mourão"]
+  spec.email         = ["eduardo.a20@gmail.com"]
+
+  spec.summary       = %q{Aircraft Avionics Built in Ruby}
+  spec.description   = %q{Aircraft Avionics Built in Ruby}
+  spec.homepage      = "https://github.com/eduardordm/enginevib"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/rtos/extconf.rb"]
+
+  spec.add_dependency "curses"
+  spec.add_dependency "rake-compiler"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rubocop"
+end

data/exe/enginevib

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+
+require 'enginevib/launcher'
+require 'enginevib/io'
+require 'enginevib/main'
+require 'enginevib/sensor'
+require 'enginevib/output'
+require 'enginevib/system'
+require 'enginevib/soft_ticker'
+require 'enginevib/scheduler'
+require 'enginevib/controller'
+require 'enginevib/stats'
+require 'enginevib/averager'
+
+
+require 'rtos'
+
+Enginevib::Main.new.launch

data/exe/openmic

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+socat -d -d pty,raw,echo=0 pty,raw,echo=0 &
+
+sleep 1
+
+while true; do rec -n stat trim 0 .001 2>&1 | awk '/^Maximum amplitude/' | cut -d":" -f2 | sed 's/ //g' > /dev/ttys000; done 
+
+

data/ext/rtos/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "rtos/rtos"

data/ext/rtos/rtos.c

@@ -0,0 +1,32 @@
+#include <ruby.h>
+#include <unistd.h>
+
+static
+VALUE initialize(VALUE self)
+{
+    return self;
+}
+
+static
+VALUE delay_rt(VALUE c, VALUE t)
+{
+    usleep(NUM2DBL(t)*1000000);
+    return Qnil;
+}
+
+static
+VALUE preempt_rt(VALUE c)
+{
+  rb_need_block();
+  rb_yield(Qnil);
+  return Qnil;
+}
+
+void Init_rtos(void)
+{
+  VALUE cRtos = rb_define_module("Rtos");
+
+  rb_define_method(cRtos, "initialize", initialize, 0);
+  rb_define_method(cRtos, "preempt_rt", preempt_rt, 0);
+  rb_define_method(cRtos, "delay_rt", delay_rt, 1);
+}

data/lib/enginevib/averager.rb

@@ -0,0 +1,27 @@
+module Enginevib
+  # Defines the Averager class
+  class Averager
+    AVERAGE_SAMPLE_SIZE = 100
+
+    def initialize(size = AVERAGE_SAMPLE_SIZE)
+      @size = size
+      @nums = []
+      @sum = 0.0
+    end
+
+    def <<(hello)
+      @nums << hello
+      goodbye = @nums.length > @size ? @nums.shift : 0
+      @sum += hello - goodbye
+      self
+    end
+
+    def average
+      @sum / @nums.length
+    end
+
+    def to_s
+      average.to_s
+    end
+  end
+end

data/lib/enginevib/controller.rb

@@ -0,0 +1,9 @@
+module Enginevib
+  # Defines a controller which can be operated by external tools
+  class Controller
+    attr_accessor :inop
+    def initialize
+      @inop = false
+    end
+  end
+end

data/lib/enginevib/io.rb

@@ -0,0 +1,13 @@
+# Non-blocking patch. I'm a terrible person.
+class IO
+  def readline_nonblock
+    rlnb_buffer = ''
+    until (ch = read_nonblock(1)).nil?
+      rlnb_buffer << ch
+      if ch == "\n"
+        result = rlnb_buffer
+        return result
+      end
+    end
+  end
+end

data/lib/enginevib/launcher.rb

@@ -0,0 +1,50 @@
+module Enginevib
+  # Defines the Launcher module which must be defined in Main.rb
+  module Launcher
+    attr_accessor :options
+
+    def launch
+      start_scheduler
+    rescue SystemExit, Interrupt
+      puts 'Good bye!' # May not be printed since we are using curses.
+    end
+
+    def parse_arguments
+      @options = {
+        simulation_mode: true,
+        serial_port: nil
+      }
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: enginevib [options]'
+        on_simulation_mode(opts)
+        on_serial_port(opts)
+        on_help(opts)
+      end.parse!
+    end
+
+    private
+
+    def on_simulation_mode(opts)
+      opts.on('-s',
+              '--simulation-mode',
+              'Enables the simulation mode and ignores --serial-port') do |s|
+        @options[:simulation_mode] = s
+      end
+    end
+
+    def on_serial_port(opts)
+      opts.on('-pSERIAL_PORT',
+              '--serial-port=SERIAL_PORT',
+              'Serial device to read data from. Example: /dev/ttys005') do |p|
+        @options[:serial_port] = p
+      end
+    end
+
+    def on_help(opts)
+      opts.on('-h', '--help', 'Prints this help') do
+        puts opts
+        exit
+      end
+    end
+  end
+end

data/lib/enginevib/main.rb

@@ -0,0 +1,40 @@
+module Enginevib
+  # The main class. run is called when run from command line.
+  class Main
+    include Launcher
+    attr_accessor :scheduler, :sensor, :output, :system, :controller
+
+    DEADLINE  = 30.0 / 1000.0  # 30 milliseconds
+    TOLERANCE = 7.0 / 1000.0   # 7 miliseconds
+    AVERAGE_SAMPLE_SIZE = 100  # 100 ticks
+
+    def initialize
+      parse_arguments
+      initialize_components
+      initialize_scheduler
+    end
+
+    def initialize_components
+      @sensor = Sensor.new(@options[:serial_port], @options[:simulation_mode])
+      @output = Output.new
+      @system = System.new
+      @controller = Controller.new
+    end
+
+    def initialize_scheduler
+      @scheduler = Scheduler.new(DEADLINE, TOLERANCE) do |stats|
+        if @controller.inop
+          sleep DEADLINE - TOLERANCE
+        else
+          data = @sensor.read
+          computed_data = @system.compute(data)
+          @output.refresh_display(computed_data, stats)
+        end
+      end
+    end
+
+    def start_scheduler
+      @scheduler.start
+    end
+  end
+end

data/lib/enginevib/output.rb

@@ -0,0 +1,55 @@
+require 'curses'
+
+module Enginevib
+  # Defines an output class
+  class Output
+    attr_accessor :screen, :window
+
+    attr_writer :warning
+
+    def initialize
+      return if $TEST
+      init_renderer
+    end
+
+    def refresh_display(data, stats)
+      return if $TEST
+      render_message data, stats
+    end
+
+    private
+
+    def init_renderer
+      setup_curses
+      @window = Curses::Window.new(8, 23,
+                                   (Curses.lines - 8) / 2,
+                                   (Curses.cols - 23) / 2)
+    end
+
+    def setup_curses
+      Curses.tap do |c|
+        c.init_screen
+        c.nonl
+        c.cbreak
+        c.noecho
+        c.curs_set(0)
+        @screen = c.stdscr
+      end
+      @screen.scrollok(false)
+    end
+
+    def render_message(data, stats)
+      @window.tap do |w|
+        w.setpos(2, 3)
+        w.addstr(data.to_s)
+        w.setpos(4, 3)
+
+        wnd = stats.window_avg
+        st = stats.warning ? 'WARN' : 'OP  '
+
+        w.addstr(">>#{st}/#{stats.memory}/#{wnd} ms   ")
+        w.refresh
+      end
+    end
+  end
+end

data/lib/enginevib/scheduler.rb

@@ -0,0 +1,70 @@
+require 'rtos'
+
+module Enginevib
+  # Defines the scheduler class
+  class Scheduler
+    include $SOFT_TICKER ? SoftTicker : Rtos
+
+    attr_accessor :deadline, :block, :tolerance, :stats, :averager, :inop
+
+    def initialize(deadline, tolerance, &block)
+      @deadline = deadline
+      @block = block
+      @tolerance = tolerance
+      @stats = Stats.new
+      @averager = Averager.new
+    end
+
+    def start
+      preempt_rt { loop { tick } }
+    end
+
+    def tick
+      execution_time = execute_block
+
+      actual_wait_time = wait_for_next_tick(execution_time)
+
+      measure_time = measure_execution(execution_time, actual_wait_time)
+
+      verify_measure_time(execution_time, actual_wait_time, measure_time)
+    end
+
+    private
+
+    def execute_block
+      Benchmark.realtime do
+        @block.call @stats
+        GC.start
+      end
+    end
+
+    def wait_for_next_tick(execution_time)
+      Benchmark.realtime do
+        delay_rt([@deadline - execution_time - tolerance, 0].max)
+      end
+    end
+
+    def measure_execution(execution_time, actual_wait_time)
+      Benchmark.realtime do
+        @stats.tap do |s|
+          s.memory =
+            GC.stat(:total_allocated_objects) - GC.stat(:total_freed_objects)
+          s.window = execution_time + actual_wait_time
+          s.warning = @stats.window > @deadline
+          measure_execution_avg
+        end
+      end
+    end
+
+    def measure_execution_avg
+      @averager << @stats.window * 1000
+      @stats.window_avg = @averager.average.to_i
+    end
+
+    def verify_measure_time(execution_time, actual_wait_time, measure_time)
+      @stats.warning =
+        (execution_time + actual_wait_time + measure_time) > @deadline
+      !@stats.warning
+    end
+  end
+end

data/lib/enginevib/sensor.rb

@@ -0,0 +1,26 @@
+module Enginevib
+  # Defines a sensor class which can read data from virtual ports, non-blocking.
+  class Sensor
+    attr_accessor :fd, :io, :buffered_data, :simulation_mode
+
+    def initialize(serial_port, simulation_mode)
+      @simulation_mode = simulation_mode
+      init_io(serial_port)
+    end
+
+    def read
+      @buffered_data =
+        @simulation_mode ? rand(0.10..1.00) : @io.readline_nonblock.to_f
+    rescue
+      @buffered_data
+    end
+
+    private
+
+    def init_io(serial_port)
+      return if @simulation_mode
+      @fd = IO.sysopen(serial_port, 'r')
+      @io = IO.new(fd, 'r')
+    end
+  end
+end

data/lib/enginevib/soft_ticker.rb

@@ -0,0 +1,12 @@
+module Enginevib
+  # Defines the soft ticker methods as a replacement for Rtos
+  module SoftTicker
+    def preempt_rt
+      yield
+    end
+
+    def delay_rt(t_seconds)
+      sleep(t_seconds)
+    end
+  end
+end

data/lib/enginevib/stats.rb

@@ -0,0 +1,13 @@
+module Enginevib
+  # A PORO. Should be faster than struct and hash.
+  class Stats
+    attr_accessor :warning, :window, :memory, :window_avg
+
+    def initialize
+      @warning = false
+      @window = 0
+      @memory = 0
+      @window_avg = 0
+    end
+  end
+end

data/lib/enginevib/system.rb

@@ -0,0 +1,15 @@
+module Enginevib
+  # Defines the system class
+  class System
+    attr_accessor :averager
+
+    def initialize
+      @averager = Averager.new
+    end
+
+    def compute(data)
+      @averager << data
+      format('%2.1f', (@averager.average * 10.0))
+    end
+  end
+end

data/lib/enginevib/version.rb

@@ -0,0 +1,4 @@
+# Version definition
+module Enginevib
+  VERSION = '0.1.0'
+end

data/lib/enginevib.rb

@@ -0,0 +1,7 @@
+require 'enginevib/version'
+
+# Enginevib module
+module Enginevib
+end
+
+require 'rtos/rtos'

data/test/averager_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class AveragerTest < Minitest::Test
+  def test_average_must_be_correct
+    avg = Enginevib::Averager.new(10)
+
+    avg << 15
+    avg << 5
+
+    assert_equal 10, avg.average
+
+    avg << 40
+
+    assert_equal 20, avg.average
+  end
+end

data/test/controller_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class ControllerTest < Minitest::Test
+  def test_must_be_always_on
+    controller = Enginevib::Controller.new
+    assert !controller.inop
+  end
+end

data/test/enginevib_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class EnginevibTest < Minitest::Test
+  def test_that_it_has_a_version_number
+    refute_nil ::Enginevib::VERSION
+  end
+end

data/test/fixtures/dummy

@@ -0,0 +1,2 @@
+1234
+1234

data/test/io_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class IoTest < Minitest::Test
+  def test_must_add_readline_nonblock_feature
+    fd = IO.sysopen("test/fixtures/dummy", 'r')
+    io = IO.new(fd, 'r')
+
+    assert io.respond_to? :readline_nonblock
+  end
+end

data/test/main_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+
+class MainTest < Minitest::Test
+  def test_must_initialize_components
+    main = Enginevib::Main.new
+    refute_nil main.controller
+    refute_nil main.sensor
+    refute_nil main.output
+  end
+
+  def test_must_initialize_scheduler
+    main = Enginevib::Main.new
+    refute_nil main.scheduler
+  end
+
+  def test_deadline_must_be_met
+    main = Enginevib::Main.new
+    (1..100).each { assert main.scheduler.tick }
+  end
+end

data/test/scheduler_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class SchedulerTest < Minitest::Test
+  def test_deadline_must_be_met
+    main = Enginevib::Main.new
+    (1..100).each { assert main.scheduler.tick }
+  end
+end

data/test/sensor_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class SensorTest < Minitest::Test
+  def test_must_run_simulation
+    sensor = Enginevib::Sensor.new(nil, true)
+    refute_nil sensor.read
+  end
+
+  def test_must_read_device
+    sensor = Enginevib::Sensor.new("test/fixtures/dummy", false)
+    assert_equal 1234.0, sensor.read
+  end
+end

data/test/soft_ticker_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class SofTickerTest < Minitest::Test
+  def test_must_comply_with_contract
+    Enginevib::SoftTicker.respond_to? :preempt_rt
+    Enginevib::SoftTicker.respond_to? :delay_rt
+  end
+end

data/test/stats_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class StatsTest < Minitest::Test
+  def test_must_initialize
+    stats = Enginevib::Stats.new
+    refute_nil stats
+  end
+
+  def test_must_initialize_with_default_values
+    stats = Enginevib::Stats.new
+    assert_equal false, stats.warning
+    assert_equal 0, stats.window
+    assert_equal 0, stats.memory
+    assert_equal 0, stats.window_avg
+  end
+end

data/test/system_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class SystemTest < Minitest::Test
+  def test_computed_data_must_be_computed
+    sys = Enginevib::System.new
+    assert_equal '1.2', sys.compute(0.12)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'benchmark'
+
+require 'enginevib/launcher'
+require 'enginevib/io'
+require 'enginevib/main'
+require 'enginevib/sensor'
+require 'enginevib/output'
+require 'enginevib/system'
+require 'enginevib/soft_ticker'
+require 'enginevib/scheduler'
+require 'enginevib/controller'
+require 'enginevib/stats'
+require 'enginevib/averager'
+require 'enginevib/version'
+
+
+require 'rtos'
+
+require 'minitest/autorun'
+
+$VERBOSE = true
+$SOFT_TICKER = false
+$TEST = true