Peeja-rubot 0.5.0

data/.autotest

@@ -0,0 +1,4 @@
+Autotest.add_hook :initialize do |at|
+  # Ignore the ._* files TextMate likes to leave about.
+  at.add_exception(/\/\._[^\/]*$/)
+end

data/Adapters.txt

@@ -0,0 +1,3 @@
+== Writing a Rubot Adapter
+
+FIXME (stub)

data/History.txt

@@ -0,0 +1,4 @@
+== 0.5.0 / 2008-04-22
+
+* First Release
+	* Major Bug: Segfaults when multiple behaviors run at once.

data/Manifest.txt

@@ -0,0 +1,47 @@
+.autotest
+Adapters.txt
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/rubot
+examples/navigate.rbt
+ext/rubot_aria/Makefile
+ext/rubot_aria/RAGenericAction.cpp
+ext/rubot_aria/RAGenericAction.h
+ext/rubot_aria/RAGenericAction.o
+ext/rubot_aria/RARobotManager.cpp
+ext/rubot_aria/RARobotManager.h
+ext/rubot_aria/RARobotManager.o
+ext/rubot_aria/extconf.rb
+ext/rubot_aria/rubot_aria.cpp
+ext/rubot_aria/rubot_aria.o
+ext/rubot_aria/rubot_aria.so
+lib/rubot.rb
+lib/rubot/adapters.rb
+lib/rubot/adapters/aria.rb
+lib/rubot/adapters/aria/action_desired.rb
+lib/rubot/adapters/aria/robot.rb
+lib/rubot/adapters/asimov.rb
+lib/rubot/dsl.rb
+lib/rubot/meta.rb
+spec/load_paths.rb
+spec/rubot/adapters/aria/robot_manager_spec.rb
+spec/rubot/adapters/aria/robot_spec.rb
+spec/rubot/adapters/aria_spec.rb
+spec/rubot/adapters/spec_helper.rb
+spec/rubot/dsl_spec.rb
+spec/rubot_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/ann.rake
+tasks/annotations.rake
+tasks/doc.rake
+tasks/gem.rake
+tasks/manifest.rake
+tasks/post_load.rake
+tasks/rubyforge.rake
+tasks/setup.rb
+tasks/spec.rake
+tasks/svn.rake
+tasks/test.rake

data/README.txt

@@ -0,0 +1,53 @@
+IMPORTANT:
+This version of Rubot is incomplete and presented publicly for the sole purpose (currently) of discussion and testing.  Many things are broken, many files are incomplete.  Even this README needs a good deal of work.
+
+=====
+
+rubot
+    by Peter Jaros (Peeja) <peter.a.jaros@gmail.com>
+    http://rubot.org/ (pending)
+
+== DESCRIPTION:
+
+FIXME (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIXME (list of features or problems)
+
+== SYNOPSIS:
+
+  rubot mycode.rbt
+
+== REQUIREMENTS:
+
+* FIXME (list of requirements)
+
+== INSTALL:
+
+* FIXME (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,31 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+load 'tasks/setup.rb'
+
+ensure_in_path 'lib'
+require 'rubot'
+
+task :default => 'spec:run'
+
+PROJ.name = 'rubot'
+PROJ.authors = 'Peter Jaros (Peeja)'
+PROJ.email = 'peter.a.jaros@gmail.com'
+PROJ.url = 'http://rubot.org/'
+# PROJ.rubyforge_name = 'rubot'
+PROJ.version = Rubot.version
+
+PROJ.executables = ['rubot']
+PROJ.dependencies << ['rice', '>= 1.0.1'] << ['facets', '>= 2.3.0']
+
+PROJ.spec_opts += File.read('spec/spec.opts').split
+PROJ.spec_opts << '-fs'
+
+# Don't expect test coverage of any file with an absolute path.
+PROJ.rcov_opts << '--exclude' << '^/' << '--exclude' << 'meta.rb$'
+PROJ.rcov_threshold_exact = true
+
+PROJ.exclude << '^\.git/' << '\.gitignore$' << '/\.DS_Store$' << '^\.DS_Store$' << '/\._' << '^\._' << 'mkmf.log'
+
+# EOF

data/bin/rubot

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+# require 'main'
+require 'rubot'
+
+# Main do
+#   argument 'file' do
+#     required
+#     description 'Rubot file to run'
+#   end
+#   
+#   def run
+#     include Rubot::DSL
+#     load params['file']
+#   end
+# end
+
+include Rubot::DSL
+load ARGV[0]

data/examples/navigate.rbt

@@ -0,0 +1,60 @@
+# navigate.rbt
+
+# Make a behavior to go forward, slowing when we approach an obstacle.
+
+behavior :go => [:max_speed, :stop_distance] do
+  sensors :sonar
+  
+  fire do
+    range = sonar.range(-70,70) - robot.radius
+    if range > stop_distance
+      speed = range * 0.3
+      speed = max_speed if (speed > max_speed)
+      desired.velocity = speed
+    else
+      desired.velocity = 0
+    end
+  end
+end
+
+
+# Make another behavior to turn us around objects we can avoid.
+
+behavior :turn => [:turn_threshold, :turn_amount] do
+  sensors :sonar
+  
+  fire do
+    # Get the left readings and right readings off of the sonar
+    left_range = sonar.range(0,100) - robot.radius
+    right_range = sonar.range(-100,0) - robot.radius
+    if left_range > turn_threshold && right_range > turn_threshold
+      # if neither left nor right range is within the turn threshold,
+      # reset the turning variable and don't turn
+      turn_direction = nil
+      desired.delta_heading = 0;
+    else
+      turn_direction ||= (left_range < right_range ? :left : :right)
+      desired.delta_heading = turn_amount * ( turn_direction == :left ? -1 : 1 )
+    end
+  end
+end
+
+
+# Set up a robot.
+
+robot :fred do
+  adapter :aria
+  host 'localhost'
+  
+  sensors :sonar
+  
+  behaviors do
+    go :priority => 50, :max_speed => 240, :stop_distance => 300
+    turn :priority => 49, :turn_threshold => 400, :turn_amount => 10
+  end
+end
+
+
+# Run it.
+
+run :fred

data/ext/rubot_aria/RAGenericAction.cpp

@@ -0,0 +1,87 @@
+#include "rice/Object.hpp"
+#include "rice/Data_Type.hpp"
+#include "rice/Symbol.hpp"
+#include "rice/Exception.hpp"
+#include "Aria.h"
+
+#include "RAGenericAction.h"
+
+using namespace Rice;
+
+RAGenericAction::RAGenericAction(const char *name)
+                : ArAction(name)
+{
+    ArLog::log(ArLog::Normal, "Created generic action \"%s\".", name);
+    myFireProc = NULL;
+    myFireProc_guard = NULL;
+    
+    // Sensors
+    mySonar = NULL;
+}
+
+RAGenericAction::~RAGenericAction()
+{
+    if (myFireProc != NULL) {
+        delete myFireProc;
+        delete myFireProc_guard;
+    }
+    ArLog::log(ArLog::Normal, "Destroyed generic action \"%s\".", getName());
+}
+
+ArActionDesired *RAGenericAction::fire(ArActionDesired currentDesired)
+{
+    myDesired.reset();
+    
+    // FIXME: myFireProc eventually has type 0 (T_NONE), and calling #call segfaults.
+    // Only happens when multiple behaviors are used at once.
+    // if (myFireProc != NULL && myFireProc->rb_type() == 0)
+    //     ArLog::log(ArLog::Normal, "Proc has type: %d.", myFireProc->rb_type());
+    
+    if (myFireProc != NULL)
+        myFireProc->call("call");
+    
+    return &myDesired;
+}
+
+void RAGenericAction::setFireProc(Object proc)
+{
+    if (!proc.is_a(rb_cProc))
+        throw Exception(rb_eArgError, "proc needs to be a Proc.");
+    if (myFireProc != NULL) {
+        delete myFireProc;
+        delete myFireProc_guard;
+    }
+    myFireProc = new Object(proc);
+    myFireProc_guard = new Address_Registration_Guard(myFireProc);
+}
+
+void RAGenericAction::setSensors(Object sensors)
+{
+    // TODO: Make sure rubot_aria supports the given sensors.
+    // ArLog::log(ArLog::Normal, "Action \"%s\"'s sensors started with \"%s\".", getName(), Symbol(mySensors.call("first")).c_str());
+    mySensors.call("replace", Array(sensors));
+    // ArLog::log(ArLog::Normal, "Action \"%s\"'s sensors now start with \"%s\".", getName(), Symbol(mySensors.call("first")).c_str());
+}
+
+void RAGenericAction::setRobot(ArRobot *robot)
+{
+    ArAction::setRobot(robot);
+    ArLog::log(ArLog::Normal, "Setting robot for action \"%s\".", getName());
+    
+    // Acquire sensors.
+    // TODO: Handle robot not supporting sensors better.
+    for (Array::iterator it = mySensors.begin(); it != mySensors.end(); ++it) {
+        if (*it == Symbol("sonar")) {
+            ArLog::log(ArLog::Normal, "Adding sonar.");
+            mySonar = robot->findRangeDevice("sonar");
+        }
+    }
+}
+
+Object RAGenericAction::getSensor(Symbol sensor)
+{
+    if (sensor == Symbol("sonar") && mySonar)
+        return to_ruby(mySonar);
+    else
+        return Object(Qnil);
+}

data/ext/rubot_aria/RAGenericAction.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "rice/Array.hpp"
+#include "rice/Object.hpp"
+#include "rice/Data_Object.hpp"
+#include "rice/Address_Registration_Guard.hpp"
+#include "Aria.h"
+
+/* 
+ * RAGenericAction
+ * Generic ArAction that runs a Ruby proc when it fires.
+ * 
+ */
+
+class RAGenericAction : public ArAction
+{
+public:
+  RAGenericAction(const char *name);
+  virtual ~RAGenericAction(void);
+  virtual ArActionDesired *fire(ArActionDesired currentDesired);
+  void setFireProc(Rice::Object proc);
+  void setSensors(Rice::Object sensors);
+  Rice::Object getSensor(Rice::Symbol sensor);
+  virtual void setRobot(ArRobot *robot);
+  ArActionDesired *getActionDesired() { return &myDesired; }
+
+protected:
+  ArActionDesired myDesired;
+  Rice::Object *myFireProc;
+  Rice::Address_Registration_Guard *myFireProc_guard;
+  Rice::Array mySensors;
+  
+  // Sensors
+  ArRangeDevice *mySonar;
+};
+
+
+// We need a disposable wrapper for ArActionDesired which Ruby can GC at its
+// pleasure.  This class delegates all calls to its wrapped ArActionDesired.
+// We have to duplicate the entirety of the interface we want Ruby to be able
+// to use.  It would be nice to automate this somehow with macros.
+
+class ArActionDesiredWrap
+{
+public:
+    ArActionDesiredWrap(ArActionDesired *obj) { myObj = obj; }
+    virtual ~ArActionDesiredWrap() {}
+    
+    double getVel() const { return myObj->getVel(); }
+    double getVelStrength() const { return myObj->getVelStrength(); }
+    void setVel(double vel, double strength) const { myObj->setVel(vel, strength); }
+
+    double getDeltaHeading() const { return myObj->getDeltaHeading(); }
+    double getDeltaHeadingStrength() const { return myObj->getDeltaHeadingStrength(); }
+    void setDeltaHeading(double deltaHeading, double strength) const { myObj->setDeltaHeading(deltaHeading, strength); }
+    
+    double getHeading() const { return myObj->getHeading(); }
+    double getHeadingStrength() const { return myObj->getHeadingStrength(); }
+    void setHeading(double heading, double strength) const { myObj->setHeading(heading, strength); }
+
+private:
+    ArActionDesired *myObj;
+};
+
+template<>
+inline
+Rice::Object to_ruby<ArActionDesired *>(ArActionDesired * const & x)
+{
+    return Rice::Data_Object<ArActionDesiredWrap>(new ArActionDesiredWrap(x));
+}
+
+
+// We also need a wrapper for ArRangeDevice.
+
+class ArRangeDeviceWrap
+{
+public:
+    ArRangeDeviceWrap(ArRangeDevice *obj) { myObj = obj; }
+    virtual ~ArRangeDeviceWrap() { }
+    
+    double currentReadingPolar(double startAngle, double endAngle)
+    {
+        return myObj->currentReadingPolar(startAngle, endAngle, NULL);
+    }
+
+private:
+    ArRangeDevice *myObj;
+};
+
+
+template<>
+inline
+Rice::Object to_ruby<ArRangeDevice *>(ArRangeDevice * const & x)
+{
+    return Rice::Data_Object<ArRangeDeviceWrap>(new ArRangeDeviceWrap(x));
+}

data/ext/rubot_aria/RARobotManager.cpp

@@ -0,0 +1,73 @@
+#include "Aria.h"
+#include "RARobotManager.h"
+
+using namespace Rice;
+
+
+RARobotManager::RARobotManager()
+              : myRobot(), myStopCB(this, &RARobotManager::stop)
+{
+    ArLog::log(ArLog::Normal, "Created robot manager.");
+    myRobotKeyHandler = NULL;
+    
+    // Sensors
+    mySonar = NULL;
+}
+
+RARobotManager::~RARobotManager()
+{
+    if (myRobotKeyHandler != NULL)
+        delete myRobotKeyHandler;
+    if (mySonar != NULL)
+        delete mySonar;
+    ArLog::log(ArLog::Normal, "Destroyed robot manager.");
+}
+
+// Connect to robot and run.
+void RARobotManager::go(const char *argString="")
+{
+    ArArgumentBuilder args;
+    args.add(argString);
+    ArSimpleConnector conn(&args);
+    conn.parseArgs();
+    // TODO: Handle connection error
+    conn.connectRobot(&myRobot);
+    myRobot.enableMotors();
+        
+    if (myRobotKeyHandler != NULL)
+        delete myRobotKeyHandler;
+    myRobotKeyHandler = new ArKeyHandler(false, false);
+    myRobotKeyHandler->addKeyHandler(ArKeyHandler::ESCAPE, &myStopCB);
+    myRobot.attachKeyHandler(myRobotKeyHandler, false);
+    
+    myRobot.run(true);
+}
+
+
+void RARobotManager::stop()
+{
+    myRobot.stopRunning();
+    if (myRobotKeyHandler != NULL) {
+        delete myRobotKeyHandler;
+        myRobotKeyHandler = NULL;
+    }
+}
+
+
+void RARobotManager::addAction(RAGenericAction *action, int priority)
+{
+    ArLog::log(ArLog::Normal, "Adding action \"%s\" with priority %d.", action->getName(), priority);
+    myRobot.addAction(action, priority);
+}
+
+
+void RARobotManager::addSensor(Symbol sensor)
+{
+    if (sensor == Symbol("sonar") && mySonar == NULL) {
+        mySonar = new ArSonarDevice;
+        myRobot.addRangeDevice(mySonar);
+    }
+    else {
+        // TODO: Tell user if sensor is not supported.
+    }
+}