Peeja-rubot 0.5.0

data/ext/rubot_aria/RARobotManager.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "Aria.h"
+#include "RAGenericAction.h"
+
+/* 
+ * RARobotManager
+ * Encapsulates an ArRobot and its connection.
+ * 
+ */
+
+class RARobotManager
+{
+public:
+    RARobotManager();
+    virtual ~RARobotManager();
+    void go(const char *argString);
+    void stop();
+    void addAction(RAGenericAction *action, int priority);
+    void addSensor(Rice::Symbol sensor);
+    double getRobotRadius() { return myRobot.getRobotRadius(); }
+
+private:
+    ArRobot myRobot;
+    ArFunctorC<RARobotManager> myStopCB;
+    ArKeyHandler *myRobotKeyHandler;
+    
+    // Sensors
+    ArSonarDevice *mySonar;
+};

data/ext/rubot_aria/extconf.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'mkmf-rice'
+
+dir_config("Aria", "/usr/local/Aria/include", "/usr/local/Aria/lib")
+unless have_library('Aria')
+  exit
+end
+
+create_makefile('rubot_aria')

data/ext/rubot_aria/rubot_aria.cpp

@@ -0,0 +1,63 @@
+#include "rice/Module.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+#include "rice/Exception.hpp"
+#include "rice/Array.hpp"
+#include "Aria.h"
+
+#include "RAGenericAction.h"
+#include "RARobotManager.h"
+
+using namespace std;
+using namespace Rice;
+
+extern "C"
+void Init_rubot_aria()
+{
+    static char inited = 0;
+    if (!inited) Aria::init(Aria::SIGHANDLE_NONE);
+    inited = 1;
+
+    Object rb_MRubot = Class(rb_cObject).const_get("Rubot");
+    Object rb_MAdapters = Module(rb_MRubot).const_get("Adapters");
+    Object rb_MAria = Module(rb_MAdapters)
+                      .define_module("Aria")
+                      ;
+  
+    
+    Data_Type<RARobotManager> rb_cRobotManager = Module(rb_MAria)
+                                                 .define_class<RARobotManager>("RobotManager")
+                                                 .define_constructor(Constructor<RARobotManager>())
+                                                 .define_method("go", &RARobotManager::go)
+                                                 .define_method("add_behavior", &RARobotManager::addAction)
+                                                 .define_method("add_sensor", &RARobotManager::addSensor)
+                                                 .define_method("robot_radius", &RARobotManager::getRobotRadius)
+                                                 ;
+    
+    Data_Type<RAGenericAction> rb_cBehavior = Module(rb_MAria)
+                                              .define_class<RAGenericAction>("Behavior")
+                                              .define_constructor(Constructor<RAGenericAction, const char *>())
+                                              .define_method("set_fire_proc", &RAGenericAction::setFireProc)
+                                              .define_method("set_sensors", &RAGenericAction::setSensors)
+                                              .define_method("get_sensor", &RAGenericAction::getSensor)
+                                              .define_method("get_desired", &RAGenericAction::getActionDesired)
+                                              ;
+    
+    Data_Type<ArActionDesiredWrap> rb_cActionDesired = Module(rb_MAria)
+                                                       .define_class<ArActionDesiredWrap>("ActionDesired")
+                                                       .define_method("velocity", &ArActionDesiredWrap::getVel)
+                                                       .define_method("velocity_strength", &ArActionDesiredWrap::getVelStrength)
+                                                       .define_method("set_velocity", &ArActionDesiredWrap::setVel)
+                                                       .define_method("delta_heading", &ArActionDesiredWrap::getDeltaHeading)
+                                                       .define_method("delta_heading_strength", &ArActionDesiredWrap::getDeltaHeadingStrength)
+                                                       .define_method("set_delta_heading", &ArActionDesiredWrap::setDeltaHeading)
+                                                       .define_method("heading", &ArActionDesiredWrap::getHeading)
+                                                       .define_method("heading_strength", &ArActionDesiredWrap::getHeadingStrength)
+                                                       .define_method("set_heading", &ArActionDesiredWrap::setHeading)
+                                                       ;
+
+    Data_Type<ArRangeDeviceWrap> rb_cRangeDevice = Module(rb_MAria)
+                                                   .define_class<ArRangeDeviceWrap>("RangeDevice")
+                                                   .define_method("range", &ArRangeDeviceWrap::currentReadingPolar)
+                                                   ;
+}

data/lib/rubot.rb

@@ -0,0 +1,14 @@
+# Require everything except things under rubot/adapters/ (which load lazily).
+# (Dir[File.join(::File.dirname(__FILE__), '**', '*.rb')] -
+#  Dir[File.join(::File.dirname(__FILE__), 'rubot', 'adapters', '**')]).sort.each {|rb| require rb}
+
+unless defined? Rubot
+
+module Rubot; end
+
+require 'rubot/meta'
+
+require 'rubot/adapters'
+require 'rubot/dsl'
+
+end

data/lib/rubot/adapters.rb

@@ -0,0 +1,39 @@
+require 'facets/string/snakecase'
+require 'facets/module/alias'
+
+# This module contains the robotics adapters.  For instance, the ACME 
+# Robotics adapter would be <tt>Rubot::Adapters::AcmeRobotics</tt>.  Its robot 
+# class would be <tt>Rubot::Adapters::AcmeRobotics::Robot</tt>, and one can be
+# created with
+# 
+#     fred = Rubot::Adapters::AcmeRobotics::Robot.new
+# 
+# or, in Rubot syntax,
+# 
+#     robot :fred do
+#       adapter :acme_robotics
+#     end
+module Rubot
+  # Raised when attempting to create a robot with an unrecognized adapter.
+  class AdapterMissingError < Exception; end
+  
+  module Adapters
+    class << self
+      def const_missing_with_autoload(name)
+        # TODO: Handle missing adapter without obscuring all LoadErrors.
+        # begin
+          req_name = "rubot/adapters/#{name.to_s.snakecase}"
+          require req_name
+          if const_defined? name
+            return const_get(name)
+          else
+            raise AdapterMissingError, "Adapter #{name} not loaded by '#{req_name}'."
+          end
+        # rescue LoadError
+        #   raise AdapterMissingError, "Adapter #{name} not found."
+        # end
+      end
+      alias_method_chain :const_missing, :autoload
+    end
+  end
+end

data/lib/rubot/adapters/aria.rb

@@ -0,0 +1,5 @@
+require 'rubot' if not defined? Rubot
+require 'rubot_aria'
+
+require File.dirname(__FILE__) + "/aria/robot"
+require File.dirname(__FILE__) + "/aria/action_desired"

data/lib/rubot/adapters/aria/action_desired.rb

@@ -0,0 +1,18 @@
+module Rubot::Adapters::Aria
+  class ActionDesired
+    %w[ velocity delta_heading heading ].each do |channel|
+      eval <<-CHAN_DEF
+        private :set_#{channel}
+
+        def #{channel}=(val)
+          # Use current channel strength, or maximum (1) if not set.
+          set_#{channel} val, (#{channel}_strength != 0 ? #{channel}_strength : 1)
+        end
+
+        def #{channel}_strength=(strength)
+          set_#{channel} #{channel}, strength
+        end
+      CHAN_DEF
+    end
+  end
+end

data/lib/rubot/adapters/aria/robot.rb

@@ -0,0 +1,30 @@
+module Rubot::Adapters::Aria
+  class Robot
+    attr_reader :options
+  
+    def initialize
+      @options = {}
+      @manager = RobotManager.new
+    end
+  
+    def run
+      args = ''
+      args << "-remoteHost #{@options[:host]} " if @options[:host]
+      args << "-remoteRobotTcpPort #{@options[:port]} " if @options[:port]
+      @manager.go args
+    end
+    
+    def add_behavior(behavior, priority)
+      raise ArgumentError, "Behavior must be an Aria::Behavior" unless behavior.instance_of? Behavior
+      @manager.add_behavior(behavior, priority)
+    end
+    
+    def add_sensor(sensor)
+      @manager.add_sensor(sensor)
+    end
+    
+    def radius
+      @manager.robot_radius
+    end
+  end
+end

data/lib/rubot/adapters/asimov.rb

@@ -0,0 +1,2 @@
+require 'rubot'
+require 'rubot_asimov'

data/lib/rubot/dsl.rb

@@ -0,0 +1,161 @@
+require 'facets/string/camelcase'
+require 'facets/symbol/to_proc'
+
+module Rubot::DSL
+  BehaviorFactories = {}
+  Robots = {}
+  
+  class BehaviorFactoryBuilder
+    def initialize(name, args, &block)
+      @name = name.to_sym
+      @args = args
+      @sensors = []
+      self.instance_eval(&block)
+    end
+    
+    # Defines the block of code to run when this behavior fires.
+    # 
+    #   behavior :do_stuff do
+    #     fire do
+    #       # Do stuff
+    #     end
+    #   end
+    def fire(&block)
+      @fire = block
+    end
+    
+    # Specifies sensors to make available to the fire block.
+    # 
+    #   behavior :log_sonar do
+    #     sensors :sonar
+    #     fire do
+    #       puts "Sonar is reading #{sonar.range(-70,70)}"
+    #     end
+    #   end
+    def sensors(*sensors)
+      @sensors += sensors.map(&:to_sym)
+    end
+    
+    def build
+      BehaviorFactory.new(@name, @args, @fire, @sensors.uniq)
+    end
+  end
+  
+  class BehaviorFactory
+    def initialize(name, accepted_args, fire, sensors)
+      @name = name
+      @accepted_args = accepted_args
+      @fire = fire
+      @sensors = sensors
+    end
+    
+    def create_for_robot(robot, adapter, given_args={})
+      BehaviorContext.new(@name, @accepted_args, @fire, @sensors, robot, adapter, given_args).behavior
+    end
+  end
+  
+  class BehaviorContext
+    attr_reader :behavior, :robot
+    def initialize(name, accepted_args, fire, sensors, robot, adapter, given_args={})
+      @name = name
+      @accepted_args = accepted_args
+      @fire = fire
+      @sensors = sensors
+      @robot = robot
+      @given_args = given_args
+      @behavior = Rubot::Adapters.const_get(adapter)::Behavior.new name.to_s
+      # Have the behavior execute the fire proc in context of this object.
+      @behavior.set_fire_proc Proc.new { self.instance_eval(&@fire) }
+      @behavior.set_sensors @sensors
+    end
+    
+    # Return the named sensor or argument.
+    def method_missing(sym, *args)
+      if @sensors.include? sym
+        @behavior.get_sensor(sym)
+      elsif @accepted_args.include? sym
+        @given_args[sym]
+      else
+        super
+      end
+    end
+    
+    def desired
+      @behavior.get_desired
+    end
+  end
+  
+  class RobotBuilder
+    attr_reader :adapter
+    def initialize(name, &block)
+      @name = name.to_sym
+      @options = {}
+      @sensors = []
+      @behaviors = []
+      self.instance_eval(&block)
+    end
+    
+    # Set the adapter for the robot, if name is given.
+    def adapter(name)
+      # TODO: Stop user from changing the adapter once set.
+      @adapter = name.to_s.camelcase(true).to_sym
+    end
+    
+    def sensors(*sensors)
+      @sensors += sensors.map(&:to_sym)
+    end
+        
+    def behaviors(&block)
+      @behaviors += RobotBehaviorsBuilder.new(&block).behaviors
+    end
+    
+    def method_missing(opt, *args)
+      @options[opt] = ( args.size == 1 ? args.first : args )
+      nil
+    end
+    
+    def build
+      raise "Robot #{@name} declared without an adapter." unless @adapter
+      robot = Rubot::Adapters.const_get(@adapter)::Robot.new
+      robot.options.merge! @options
+      @sensors.each { |s| robot.add_sensor s }
+      @behaviors.each do |name, priority, args|
+        b = BehaviorFactories[name].create_for_robot(robot, @adapter, args)
+        robot.add_behavior b, priority
+      end
+      robot
+    end
+  end
+  
+  # Builds up a list of behaviors for the robot.
+  class RobotBehaviorsBuilder
+    attr_reader :behaviors
+    def initialize(&block)
+      @behaviors = []
+      self.instance_eval(&block)
+    end
+    
+    def method_missing(name, args={})
+      priority = args.delete(:priority) do |_|
+        # TODO: raise hell if priority is not given.
+      end
+      @behaviors << [name.to_sym, priority, args]
+    end
+  end
+  
+  def behavior(name, &block)
+    name, args = name.to_a.first if name.instance_of? Hash
+    args ||= []
+    bb = BehaviorFactoryBuilder.new(name, args, &block)
+    BehaviorFactories[name.to_sym] = bb.build
+  end
+  
+  def robot(name, &block)
+    rb = RobotBuilder.new(name, &block)
+    Robots[name.to_sym] = rb.build
+  end
+  
+  def run(name)
+    Robots[name].run
+  end
+end

data/lib/rubot/meta.rb

@@ -0,0 +1,13 @@
+module Rubot
+  # :stopdoc:
+  VERSION = '0.5.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+end

data/spec/load_paths.rb

@@ -0,0 +1,9 @@
+# Adds load paths to extensions for RSpec.  At build, extensions end up in lib/ anyhow.
+Dir['ext/*'].each do |dir|
+  if test ?d, dir
+    $LOAD_PATH.unshift dir
+  end
+end
+
+# The rake task takes care of this for us, but autotest needs it.
+$LOAD_PATH.unshift 'lib' unless $LOAD_PATH.include? 'lib'

data/spec/rubot/adapters/aria/robot_manager_spec.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe Rubot::Adapters::Aria::RobotManager do
+  it "should be creatable" do
+    lambda { Rubot::Adapters::Aria::RobotManager.new }.should_not raise_error
+  end
+  
+  # We can't really test that #go works, but we can make sure it's defined.
+  it "should connect to robot" do
+    Rubot::Adapters::Aria::RobotManager.instance_methods.should include("go")
+  end
+end

data/spec/rubot/adapters/aria/robot_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+# fred = Rubot::Adapters::Aria::Robot.new
+# fred.options[:host] = 'localhost'
+
+include Rubot::Adapters::Aria
+
+describe Robot do
+  before(:each) do
+    @mock_manager = mock("manager")
+    RobotManager.stub!(:new).and_return(@mock_manager)
+    @robot = Robot.new
+  end
+  
+  it "should have options hash" do
+    @robot.options[:be_awesome] = true
+    @robot.options.keys.should include(:be_awesome)
+  end
+  
+  it "should run the robot" do
+    @mock_manager.should_receive(:go)
+    @robot.run
+  end
+  
+  it "should connect to the specified host" do
+    @robot.options[:host] = 'robothost'
+    @mock_manager.should_receive(:go).with(/-remoteHost robothost/)
+    @robot.run
+  end
+  
+  it "should connect to the specified port" do
+    @robot.options[:port] = 3456
+    @mock_manager.should_receive(:go).with(/-remoteRobotTcpPort 3456/)
+    @robot.run
+  end
+
+  # TODO: Add serial connection support.
+end