flying_robot 0.0.3

data/History.txt

@@ -0,0 +1,14 @@
+== 0.0.1 2009-04-03
+
+* 1 major enhancement:
+  * Initial release
+
+== 0.0.2 2009-07-08
+
+* 1 major enhancement:
+  * Plugin support for all hardware included with Blimpduino, including L293D and Maxsonar Ultrasonic range finder
+
+== 0.0.3 2009-11-14
+
+* 1 major enhancement:
+  * Update parser for aileron command support

data/Manifest.txt

@@ -0,0 +1,29 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+README.txt
+Rakefile
+app_generators/flying_robot/USAGE
+app_generators/flying_robot/flying_robot_generator.rb
+app_generators/flying_robot/templates/plugins/Hmc6352_compass.rb
+app_generators/flying_robot/templates/plugins/battery.rb
+app_generators/flying_robot/templates/plugins/flying_robot.rb
+app_generators/flying_robot/templates/plugins/pololu_ir_receiver.rb
+app_generators/flying_robot/templates/plugins/pololu_micro_serial_controller.rb
+app_generators/flying_robot/templates/plugins/pololu_qik_dual_serial_motor_controller.rb
+app_generators/flying_robot/templates/plugins/L293d.rb
+app_generators/flying_robot/templates/plugins/maxsonar.rb
+app_generators/flying_robot/templates/sketch.rb.erb
+bin/flying_robot
+flying_robot.gemspec
+lib/flying_robot.rb
+script/console
+script/destroy
+script/generate
+spec/flying_robot_spec.rb
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake
+test/test_flying_robot_generator.rb
+test/test_generator_helper.rb

data/PostInstall.txt

@@ -0,0 +1,3 @@
+
+For more information on flying_robot, see http://flyingrobo.com
+

data/README.rdoc

@@ -0,0 +1,58 @@
+= flying_robot
+
+http://github.com/deadprogrammer/flying_robot
+
+== DESCRIPTION:
+
+flying_robot takes a standard Ruby Arduino Development (RAD) project, and turns it into a Unmanned Aerial Vehicle (UAV)
+
+== FEATURES/PROBLEMS:
+
+* Plugins for RAD for cool UAV-related hardware, like Pololu motor controllers and Honeywell digital compass
+* Complete support for Blimpduino hardware
+* More plugins coming soon to support other available Arduino-based systems like ArduPilot
+
+== SYNOPSIS:
+
+flying_robot takes a standard Ruby Arduino Development (RAD) project, and turns it into a Unmanned Aerial Vehicle (UAV). It includes plugin support for the following hardware:
+
+* LiPo Battery Voltage
+* Honeywell HMC6352 Digital Compass
+* L293D Motor Driver
+* Maxbotix Maxsonar Ultrasonic Range Finder
+* Pololu Infrared Detector Array
+* Pololu Micro Serial Motor Controller
+* Pololu QIK Dual Serial Motor Controller
+
+== REQUIREMENTS:
+
+* sudo gem install rad
+
+== INSTALL:
+
+* sudo gem install deadprogrammer-flying_robot
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Ron Evans
+
+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/README.txt

@@ -0,0 +1,58 @@
+= flying_robot
+
+http://github.com/deadprogrammer/flying_robot
+
+== DESCRIPTION:
+
+flying_robot takes a standard Ruby Arduino Development (RAD) project, and turns it into a Unmanned Aerial Vehicle (UAV)
+
+== FEATURES/PROBLEMS:
+
+* Plugins for RAD for cool UAV-related hardware, like Pololu motor controllers and Honeywell digital compass
+* Complete support for Blimpduino hardware
+* More plugins coming soon to support other available Arduino-based systems like ArduPilot
+
+== SYNOPSIS:
+
+flying_robot takes a standard Ruby Arduino Development (RAD) project, and turns it into a Unmanned Aerial Vehicle (UAV). It includes plugin support for the following hardware:
+
+* LiPo Battery Voltage
+* Honeywell HMC6352 Digital Compass
+* L293D Motor Driver
+* Maxbotix Maxsonar Ultrasonic Range Finder
+* Pololu Infrared Detector Array
+* Pololu Micro Serial Motor Controller
+* Pololu QIK Dual Serial Motor Controller
+
+== REQUIREMENTS:
+
+* sudo gem install rad
+
+== INSTALL:
+
+* sudo gem install deadprogrammer-flying_robot
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Ron Evans
+
+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,13 @@
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'flying_robot' do
+  developer('Ron Evans', 'ron dot evans at gmail dot com')
+
+  self.rubyforge_name = 'deadprogrammer'
+end
+
+task :cultivate do
+  system "touch Manifest.txt; rake check_manifest | grep -v \"(in \" | patch"
+  system "rake debug_gem | grep -v \"(in \" > `basename \\`pwd\\``.gemspec"
+end

data/app_generators/flying_robot/USAGE

@@ -0,0 +1,7 @@
+Description:
+  
+  flying_robot takes a standard Ruby Arduino Development (RAD) project, and turns it into a Unmanned Aerial Vehicle (UAV)
+  
+Usage:
+  
+  flying_robot [appname]

data/app_generators/flying_robot/flying_robot_generator.rb

@@ -0,0 +1,75 @@
+class FlyingRobotGenerator < RubiGen::Base
+
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory ''
+      BASEDIRS.each { |path| m.directory path }
+
+      # create stub
+      m.template 'sketch.rb.erb'   , "#{base_name}.rb"
+      
+      # copy plugins
+      m.file     "plugins/battery.rb",                                  "vendor/plugins/battery.rb"
+      m.file     "plugins/flying_robot.rb",                             "vendor/plugins/flying_robot.rb"
+      m.file     "plugins/Hmc6352_compass.rb",                          "vendor/plugins/Hmc6352_compass.rb"
+      m.file     "plugins/pololu_ir_receiver.rb",                       "vendor/plugins/pololu_ir_receiver.rb"
+      m.file     "plugins/pololu_micro_serial_controller.rb",           "vendor/plugins/pololu_micro_serial_controller.rb"
+      m.file     "plugins/pololu_qik_dual_serial_motor_controller.rb",  "vendor/plugins/pololu_qik_dual_serial_motor_controller.rb"
+      m.file     "plugins/L293d.rb",                                    "vendor/plugins/L293d.rb"
+      m.file     "plugins/maxsonar.rb",                                 "vendor/plugins/maxsonar.rb"
+      
+      m.dependency "install_rubigen_scripts", [destination_root, 'flying_robot'],
+        :shebang => options[:shebang], :collision => :force
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |o| options[:author] = o }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      vendor/plugins
+      examples
+    )
+end

data/app_generators/flying_robot/templates/plugins/Hmc6352_compass.rb

@@ -0,0 +1,56 @@
+# Plugin for Ruby Arduino Development that allows use of the HMC6352 Compass module
+# Written by Ron Evans (http://deadprogrammersociety.com) for the flying_robot project
+#
+# Based on code taken from the SparkFun forums: http://forum.sparkfun.com/viewtopic.php?t=6236
+class Hmc6352Compass < ArduinoPlugin
+  include_wire
+  
+  external_variables "int HMC6352Address = 0x42"
+  external_variables "byte headingData[2]"
+  external_variables "int headingValue = 0"
+  
+  # Shift the device's documented slave address (0x42) 1 bit right
+  # This compensates for how the TWI library only wants the
+  # 7 most significant bits (with the high bit padded with 0)
+  # This results in 0x21 as the address to pass to TWI
+  external_variables "int slaveAddress = HMC6352Address >> 1"
+  
+  void prepare_compass() {
+    // hack to reference plugin, copied this trick from twitter plugin 
+  }
+  
+  // The whole number part of the heading
+  int heading()
+  {
+    return int (headingValue / 10) ;
+  }
+  
+  // The fractional part of the heading
+  int heading_fractional()
+  {
+    return int (headingValue % 10) ;
+  }
+  
+  void read_compass()
+  {
+    // Send a "A" command to the HMC6352
+    // This requests the current heading data
+    Wire.beginTransmission(slaveAddress);
+    Wire.send("A");              // The "Get Data" command
+    Wire.endTransmission();
+    delay(10);                   // The HMC6352 needs at least a 70us (microsecond) delay
+    // after this command.  Using 10ms just makes it safe
+    // Read the 2 heading bytes, MSB first
+    // The resulting 16bit word is the compass heading in 10ths of a degree
+    // For example: a heading of 1345 would be 134.5 degrees
+    Wire.requestFrom(slaveAddress, 2);        // Request the 2 byte heading (MSB comes first)
+    int i = 0;
+    while(Wire.available() && i < 2)
+    { 
+      headingData[i] = Wire.receive();
+      i++;
+    }
+    headingValue = headingData[0]*256 + headingData[1];  // Put the MSB and LSB together
+  } 
+  
+end

data/app_generators/flying_robot/templates/plugins/L293d.rb

@@ -0,0 +1,27 @@
+# Plugin for Ruby Arduino Development that allows use of the L293D motor controller
+# Written by Ron Evans (http://deadprogrammersociety.com) for the flying_robot project
+#
+#
+# Adapted from code written by Jordi Muñoz for the Blimpduino project 
+# http://blimpduino.googlecode.com/svn/trunk/Motors.pde
+#
+class L293d < ArduinoPlugin
+  plugin_directives "#define FORWARD 1"
+  plugin_directives "#define REVERSE 0"
+
+  void L293_send_command(int directionPin, int speedPin, byte direction, byte speed)
+  {
+    direction = constrain(direction, 0, 1);
+    speed = constrain(speed, 0, 127);
+
+    if (direction == FORWARD) {
+      digitalWrite(directionPin, LOW);
+      analogWrite(speedPin, speed);
+    } else {
+      speed = 255 - speed ;
+      digitalWrite(directionPin, HIGH);
+      analogWrite(speedPin, speed);
+    }
+  }
+
+end

data/app_generators/flying_robot/templates/plugins/battery.rb

@@ -0,0 +1,41 @@
+# Plugin for Ruby Arduino Development that reads a battery voltage from a power source that has been connected
+# to one of the Arduino's analog pins. Note that you probably need to reduce the voltage considerably with a resistor (10K value?)
+# before feeding it to the analog pin. You should also add another 10K resistor as a pull-down from the pin to ground.
+#
+# Written by Ron Evans (http://deadprogrammersociety.com) for the flying_robot project
+# http://github.com/deadprogrammer/flying_robot
+#
+# Adapted from code written by Jordi Muñoz for the Blimpduino project 
+# http://code.google.com/p/blimpduino/source/browse/trunk/BlimpDuino_v4.pde)
+#
+class Battery < ArduinoPlugin
+  external_variables "float average_battery = 0.0"
+  external_variables "bool battery_init_completed"
+  
+  add_to_setup "battery_init_completed = false;"
+  
+  # bogus function here to make RAD happy
+  void battery_test() {
+  }
+
+  // initialize the battery reading
+  void init_battery(int pin) {
+    average_battery = analogRead(pin);
+  }
+
+  // get the current voltage
+  // TODO: allow user to set constants for different expected battery voltages
+  float voltage(int pin)
+  {
+    if (! battery_init_completed) {
+      init_battery(pin);
+    }
+    
+    average_battery=(((float) average_battery * 0.99) + (float)((float) analogRead(pin) * 0.01)); // Jordi called it dynamic average
+
+    float battery_voltage=(float)((float) average_battery * (float)4.887586) * (float)2; // converting values to millivolts..,
+
+    return battery_voltage ;
+  }
+
+end

data/app_generators/flying_robot/templates/plugins/flying_robot.rb

@@ -0,0 +1,282 @@
+# Plugin for Ruby Arduino Development that parses the flying_robot command set from any source of input to the serial port
+# Written by Ron Evans (http://deadprogrammersociety.com) for the flying_robot project
+#
+# In order to implement a sketch that uses the flying_robot parser, you need to implement the methods that make up its interface
+# so that it will respond to the standard command set.
+# 
+# The following commands are supported:
+# (h)ail - See if the UAV can still respond. Should send "Roger" back.
+# (s)tatus - Grab a snapshot of all instrument readings plus any other status info that the UAV can support
+# (e)levators - Set the elevators. The command supports two parameters:
+#   direction - enter 'u' for up, 'c' for centered, or 'd' for down
+#   deflection - enter an angle between 0 and 90 degrees
+# (r)udder - Set the rudder. This command supports two parameters:
+#   direction - enter 'l' for left, 'c' for centered, or 'r' for right
+#   deflection - enter an angle between 0 and 90 degrees
+# (a)ilerons - Set the ailerons. This command supports two parameters:
+#   direction - enter 'l' for left, 'c' for centered, or 'r' for right
+#   deflection - enter an angle between 0 and 90 degrees
+# (t)hrottle - Set the throttle. This command supports two parameters:
+#   direction - enter 'f' for forward, or 'r' for reverse
+#   speed - enter a percentage from 0 to 100
+# (i)nstruments - Read the current data for one of the installed instruments on the UAV. This command supports one parameter:
+#   id - enter an integer for which instrment readings should be returned from. If there is not an instrument installed
+#        for that id 'Invalid instrument' will be returned
+# (p)rogram - Engage whatever autopilot program is available, if any. This command supports one parameter:
+#   id - enter an integer for which autopilot routine should be used. Enter 0 to cancel autopilot
+#
+class FlyingRobot < ArduinoPlugin
+  # used for parsing input commands
+  external_variables "bool current_command_received_complete"
+  external_variables "int current_command_length"
+  external_variables "char command_buffer[120]"
+
+  # the parsed command
+  external_variables "char command_code[1]"
+  external_variables "char direction_code[1]"
+  external_variables "char instrument_code[1]"
+  external_variables "char autopilot_code[1]"
+  external_variables "int command_value"
+    
+  # current elevator values
+  external_variables "char elevator_direction[1]"
+  external_variables "int elevator_deflection = 0"
+  
+  # current rudder values
+  external_variables "char rudder_direction[1]"
+  external_variables "int rudder_deflection = 0"
+
+  # current aileron values
+  external_variables "char aileron_direction[1]"
+  external_variables "int aileron_deflection = 0"
+  
+  # current throttle values
+  external_variables "char throttle_direction[1]"
+  external_variables "int throttle_speed = 0"
+  
+  # autopilot
+  external_variables "bool autopilot_engaged"
+    
+  # initialize parser vars
+  add_to_setup "current_command_received_complete = false; elevator_direction[0] = 'c'; rudder_direction[0] = 'c'; throttle_direction[0] = 'f'; autopilot_engaged = false;"
+  
+  # this is a hack to get the plugin included, that I got from the twitter_connect example
+  void be_flying_robot(){}
+  
+  boolean current_command_received_is_complete() {
+    return current_command_received_complete == true ;
+  }
+  
+  char current_command() {
+    return command_code[0];
+  }
+
+  char current_command_direction() {
+    return direction_code[0];
+  }
+
+  char current_command_instrument() {
+    return instrument_code[0];
+  }
+
+  char current_command_autopilot() {
+    return autopilot_code[0];
+  }
+  
+  int current_command_value() {
+    return command_value ;
+  }
+  
+  char current_elevator_direction() {
+    return elevator_direction[0];
+  }
+  
+  int current_elevator_deflection() {
+    return elevator_deflection ;
+  }
+
+  char current_aileron_direction() {
+    return aileron_direction[0];
+  }
+  
+  int current_aileron_deflection() {
+    return aileron_deflection ;
+  }
+
+  char current_rudder_direction() {
+    return rudder_direction[0];
+  }
+  
+  int current_rudder_deflection() {
+    return rudder_deflection ;
+  }
+
+  char current_throttle_direction() {
+    return throttle_direction[0];
+  }
+  
+  int current_throttle_speed() {
+    return throttle_speed ;
+  }
+  
+  boolean is_autopilot_on() {
+    return autopilot_engaged == true ;
+  }
+  
+  void autopilot_on() {
+    autopilot_engaged = true;
+  }
+
+  void autopilot_off() {
+    autopilot_engaged = false;
+  }
+  
+  void clear_command_buffer() {
+    for(int i=0; i<120; i++){
+      command_buffer[i] = 0 ;
+    }
+    
+    command_code[0] = 0 ;
+    direction_code[0] = 0 ;
+    instrument_code[0] = 0 ;
+    current_command_length = 0 ;
+    current_command_received_complete = false ;
+  }
+  
+  void parse_command_code() {
+    if(current_command_length == 0) {
+      command_code[0] = 0;
+    } else {
+      command_code[0] = command_buffer[0];
+    }
+  }
+
+  void parse_direction_code() {
+    if(current_command_length >= 3) {
+      direction_code[0] = command_buffer[2];
+    } else {
+      direction_code[0] = 0;
+    }
+  }
+
+  void parse_instrument_code() {
+    if(current_command_length >= 3) {
+      instrument_code[0] = command_buffer[2];
+    } else {
+      instrument_code[0] = 0;
+    }
+  }
+
+  void parse_autopilot_code() {
+    if(current_command_length >= 3) {
+      autopilot_code[0] = command_buffer[2];
+    } else {
+      autopilot_code[0] = 0;
+    }
+  }
+
+  void parse_command_value(int start) {
+    if(current_command_length >= start + 1) {
+      command_value = atoi(command_buffer + start);
+    } else {
+      command_value = 0 ;
+    }
+  }
+  
+  void get_command() {
+    if(current_command_received_complete) {
+      clear_command_buffer();
+    }
+    
+    while(Serial.available() > 0) {
+      command_buffer[current_command_length] = Serial.read();
+      if(command_buffer[current_command_length] == '\r') {
+        current_command_received_complete = true ;
+        parse_command_code();
+        return;
+      } else {
+        current_command_length++ ;
+      }
+    }
+  }
+  
+  // used to echo the commands being received via serial
+  void print_current_command(const char* cmd, int val) {
+    Serial.print(cmd);
+    Serial.print(" command - direction:");
+    Serial.print(current_command_direction());
+    Serial.print(" value:");
+    Serial.println(val);    
+  }
+  
+  void dispatch_command() {
+    if(!current_command_received_is_complete()) {
+      return;
+    }
+    
+    char cmd = current_command(); 
+    
+    if (cmd == 'h') {
+      hail();
+    } else if (cmd == 's') {  
+      status();
+    } else if (cmd == 'e') {
+      parse_direction_code();
+      parse_command_value(4);
+      elevator_direction[0] = current_command_direction();
+      elevator_deflection = current_command_value();
+      if (elevator_deflection > 90) {
+        elevator_deflection = 90 ;
+      }
+      
+      elevators();
+    } else if (cmd == 'r') { 
+      parse_direction_code();
+      parse_command_value(4);
+      rudder_direction[0] = current_command_direction();
+      rudder_deflection = current_command_value();
+      if (rudder_deflection > 90) {
+        rudder_deflection = 90 ;
+      }
+      
+      rudder();
+    } else if (cmd == 'a') { 
+      parse_direction_code();
+      parse_command_value(4);
+      aileron_direction[0] = current_command_direction();
+      aileron_deflection = current_command_value();
+      if (aileron_deflection > 90) {
+        aileron_deflection = 90 ;
+      }
+
+      ailerons();
+    } else if (cmd == 't') {
+      parse_direction_code();
+      parse_command_value(4);
+      throttle_direction[0] = current_command_direction();
+      throttle_speed = current_command_value();
+      if (throttle_speed > 100) {
+        throttle_speed = 100 ;
+      }
+      
+      throttle();
+    } else if (cmd == 'i') {    
+      parse_instrument_code();
+      instruments();
+    } else if (cmd == 'p') {    
+      parse_autopilot_code();
+      if (autopilot_code[0] == '0') {
+        autopilot_off();
+      }
+        
+      autopilot();
+    } else {    
+      Serial.println("Invalid command");
+    }    
+  }
+  
+  void process_command() {
+    get_command();
+    dispatch_command();
+  }
+end