rad 0.2.0 → 0.2.1

data/History.txt

@@ -1,3 +1,12 @@
+== 0.2.1 2008-04-02
+* 6ish updates:
+	- applied Brian Riley's SWSerLCDpa patch
+	- experimental libraries system in vendor/libraries
+	- fixed require 'yaml' bug in makefile.rb
+	- enhancements to the rad command: can set project config.
+	- added first significant documentation 
+	- added examples directory to the website
+
 == 0.2.0 2008-03-15
 * 8ish updates, some major:
 	* fixed regular serial support

data/Manifest.txt

@@ -4,6 +4,9 @@ Manifest.txt
 README.txt
 Rakefile
 bin/rad
+lib/libraries/SWSerLCDpa/keywords.txt
+lib/libraries/SWSerLCDpa/SWSerLCDpa.cpp
+lib/libraries/SWSerLCDpa/SWSerLCDpa.h
 lib/rad.rb
 lib/rad/arduino_sketch.rb
 lib/rad/init.rb

data/README.txt

@@ -1,3 +1,43 @@
-README for rad
-==============
+=Welcome to RAD (Ruby Arduino Development)
 
+RAD is a framework for programming the Arduino physcial computing platform using Ruby. RAD converts Ruby scripts written using a set of Rails-like conventions and helpers into C source code which can be compiled and run on the Arduino microcontroller. It also provides a set of Rake tasks for automating the compilation and upload process.
+
+For a full introduction see http://rad.rubyforge.org
+
+==Documentation
+
+The main documentation is here: ArduinoSketch.
+
+See also the Arduino Software reference: http://www.arduino.cc/en/Reference/HomePage
+
+==Examples
+
+See the examples directory for lots of examples of RAD in action: http://rad.rubyforge.org/examples
+
+==Getting Started
+
+Install the gem:
+
+$ sudo gem install rad
+
+Run the rad command to create a new project:
+
+$ rad my_project
+
+Write a sketch that will blink a single LED every 500ms:
+
+  class MyProject < ArduinoSketch
+  	output_pin 13, :as => led
+  	
+  	def loop
+  		blink led, 500
+  	end
+  end
+
+Attach your Arduino and use rake to complile and upload your sketch:
+
+$ rake make:upload
+
+==Get Involved
+
+Cheers? Jeers? Wanna help out? Contact Greg Borenstein: greg [dot] borenstein [at] gmail [dot] com

data/bin/rad

@@ -8,29 +8,107 @@ end
 
 require 'optparse'
 require 'fileutils'
+require 'yaml'
 
-parser = OptionParser.new do |opts|
-  opts.banner = <<BANNER
-Build a directory for your RAD Sketch and install RAD in its vendor sub-directory.
 
-Usage: #{File.basename($0)} <sketch_dir_name>
-BANNER
 
-  opts.on("-h", "--help",
-          "Show this help message.") { puts opts; exit }
-  opts.parse!(ARGV)
+class OptionParser #:nodoc:
+    
+  def self.parse(args)
+    # defaults
+    
+    options = {"hardware" => {
+                "serial_port"      => '/dev/tty.usbserial*', 
+                "mcu"              => "atmega168", 
+                "physical_reset"   => false
+                },
+                "software" => {
+                  "arduino_root"   => "/Applications/arduino-0010"
+                 }
+               }
+    
+    opts = OptionParser.new do |opts|
+      
+      opts.banner = <<-BANNER
+Build a directory for your RAD Project and install RAD in its vendor sub-directory.
+
+Usage: #{File.basename($0)} <sketch_dir_name> <options for config>
+      BANNER
+      
+      opts.on("-p", "--port [SERIAL PORT]", 
+              "Path to your serial port", 
+              "   (default: #{options['hardware']['serial_port']})") do |port|
+              
+        options["hardware"]["serial_port"] = port if port
+      end
+      
+       opts.on("-m", "--mcu [PROCESSOR TYPE]", 
+              "Type of processor on your board", 
+              "   (default: #{options['hardware']['mcu']})") do |port|
+              
+        options["hardware"]["serial_port"] = port if port
+      end
+      
+      opts.on("-r", "--reset [RESET REQUIRED]", 
+              "Require a hardware reset before uploading?",
+              "   (default: #{options['hardware']['physical_reset']})") do |no_reset|
+        options["hardware"]["physical_reset"] = true unless no_reset
+      end
+      
+      opts.on("-a", "--arduino [ARDUINO DIR]", 
+              "Path to your Arduino install",
+              "   (default: #{options['software']['arduino_root']})") do |arduino|
+        options["software"]["arduino_root"] = arduino if arduino
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+    
+    opts.parse!(args)
+    [options, opts]
+  end
+  
 end
 
+
+# home = ENV['HOME'] || ENV['USERPROFILE'] || ENV['HOMEPATH']
+# begin
+#   config = YAML::load open(home + "/.rad")
+# rescue
+#   config = false
+# end
+# 
+
+
+# Handle options:
+options, parser = OptionParser.parse(ARGV)
 sketch_name = ARGV[0]
 parser.parse!(["-h"]) unless sketch_name 
+  
 
+# Build vendor/rad:  
+  
 FileUtils.mkdir_p "#{sketch_name}/vendor/rad"
 puts "Successfully created your sketch directory."
 
 FileUtils.cp_r "#{File.dirname(__FILE__)}/../lib/rad/.", "#{sketch_name}/vendor/rad"
-puts "Installed RAD library into #{sketch_name}/vendor/rad"
+puts "Installed RAD into #{sketch_name}/vendor/rad"
+puts
+
+# Build vendor/libraries:  
+
+FileUtils.mkdir_p "#{sketch_name}/vendor/libraries"
+puts "Successfully created your libraries directory."
+
+FileUtils.cp_r "#{File.dirname(__FILE__)}/../lib/libraries/SWSerLCDpa/.", "#{sketch_name}/vendor/libraries/SWSerLCDpa"
+puts "Installed SWSerLCDpa into #{sketch_name}/vendor/libraries"
 puts
 
+# Build sketch files, etc.:  
+
 FileUtils.touch "#{sketch_name}/#{sketch_name}.rb"
 File.open("#{sketch_name}/#{sketch_name}.rb", "w") do |file|
   file << <<-EOS
@@ -51,18 +129,12 @@ FileUtils.mkdir_p "#{sketch_name}/config"
 puts "Added #{sketch_name}/config"
 
 File.open("#{sketch_name}/config/hardware.yml", 'w') do |file|
-  file << <<-EOS 
-serial_port: /dev/tty.usbserial*
-mcu: atmega168
-physical_reset: false
-  EOS
+  file << options["hardware"].to_yaml
 end
 puts "Added #{sketch_name}/config/hardware.yml"
 
 File.open("#{sketch_name}/config/software.yml", 'w') do |file|
-  file << <<-EOS 
-arduino_root: /Applications/arduino-0010
-  EOS
+  file << options["software"].to_yaml
 end
 puts "Added #{sketch_name}/config/software.yml"
 

data/lib/libraries/SWSerLCDpa/SWSerLCDpa.cpp

@@ -0,0 +1,250 @@
+/*
+  SWSerLCDpa.cpp - Software serial to Peter Anderson controller chip based
+  LCD display library Adapted from SoftwareSerial.cpp (c) 2006 David A. Mellis
+  by Brian B. Riley, Underhill Center, Vermont, USA, July 2007
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+/******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include "WConstants.h"
+#include "SWSerLCDpa.h"
+
+/******************************************************************************
+ * Definitions
+ ******************************************************************************/
+
+/******************************************************************************
+ * Constructors
+ ******************************************************************************/
+
+SWSerLCDpa::SWSerLCDpa(uint8_t transmitPin)
+{
+  _transmitPin = transmitPin;
+  _baudRate = 0;
+}
+
+/******************************************************************************
+ * User API
+ ******************************************************************************/
+
+void SWSerLCDpa::begin(long speed)
+{
+  _baudRate = speed;
+  _bitPeriod = 1000000 / _baudRate;
+
+  digitalWrite(_transmitPin, HIGH);
+  delayMicroseconds( _bitPeriod); // if we were low this establishes the end
+}
+
+void SWSerLCDpa::print(uint8_t b)
+{
+  if (_baudRate == 0)
+    return;
+    
+  int bitDelay = _bitPeriod - clockCyclesToMicroseconds(50); // a digitalWrite is about 50 cycles
+  byte mask;
+
+  digitalWrite(_transmitPin, LOW);
+  delayMicroseconds(bitDelay);
+
+  for (mask = 0x01; mask; mask <<= 1) {
+    if (b & mask){ // choose bit
+      digitalWrite(_transmitPin,HIGH); // send 1
+    }
+    else{
+      digitalWrite(_transmitPin,LOW); // send 1
+    }
+    delayMicroseconds(bitDelay);
+  }
+
+  digitalWrite(_transmitPin, HIGH);
+  delayMicroseconds(bitDelay);
+}
+
+void SWSerLCDpa::print(const char *s)
+{
+  while (*s) {
+    print(*s++);
+    delay(1);
+  }
+}
+
+void SWSerLCDpa::print(char c)
+{
+  print((uint8_t) c);
+}
+
+void SWSerLCDpa::print(int n)
+{
+  print((long) n);
+}
+
+void SWSerLCDpa::print(unsigned int n)
+{
+  print((unsigned long) n);
+}
+
+void SWSerLCDpa::print(long n)
+{
+  if (n < 0) {
+    print('-');
+    n = -n;
+  }
+  printNumber(n, 10);
+}
+
+void SWSerLCDpa::print(unsigned long n)
+{
+  printNumber(n, 10);
+}
+
+void SWSerLCDpa::print(long n, int base)
+{
+  if (base == 0)
+    print((char) n);
+  else if (base == 10)
+    print(n);
+  else
+    printNumber(n, base);
+}
+
+// -------- PHA unique codes -------------------------
+void SWSerLCDpa::println(void)
+{
+  print("?n");
+  delay(10);
+}
+
+void SWSerLCDpa::clearscr(void)
+{
+  print("?f");
+  delay(100);
+}
+
+void SWSerLCDpa::home(void)
+{
+  print("?a");
+  delay(10);
+}
+
+
+void SWSerLCDpa::setgeo(int geometry)
+{
+  print("?G");
+  print(geometry);
+  delay(200);
+}
+
+void SWSerLCDpa::setintensity(int intensity)
+{
+  print("?B");
+  if (intensity < 16)
+  	print('0');
+  print(intensity, 16);
+  delay(200);
+}
+
+void SWSerLCDpa::intoBignum(void)
+{
+  print("?>3");
+}
+
+void SWSerLCDpa::outofBignum(void)
+{
+  print("?<");
+}
+
+
+void SWSerLCDpa::setxy(int x, int y)
+{
+  print("?y");
+  print(y);	
+  print("?x");
+  if (x < 10)
+    print('0');
+  print(x);
+  delay(10);
+}
+
+
+void SWSerLCDpa::println(char c)
+{
+  print(c);
+  println();  
+}
+
+void SWSerLCDpa::println(const char c[])
+{
+  print(c);
+  println();
+}
+
+void SWSerLCDpa::println(uint8_t b)
+{
+  print(b);
+  println();
+}
+
+void SWSerLCDpa::println(int n)
+{
+  print(n);
+  println();
+}
+
+void SWSerLCDpa::println(long n)
+{
+  print(n);
+  println();  
+}
+
+void SWSerLCDpa::println(unsigned long n)
+{
+  print(n);
+  println();  
+}
+
+void SWSerLCDpa::println(long n, int base)
+{
+  print(n, base);
+  println();
+}
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+void SWSerLCDpa::printNumber(unsigned long n, uint8_t base)
+{
+  unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars. 
+  unsigned long i = 0;  	
+
+  if (n == 0) {
+    print('0');
+    return;
+  } 
+
+  while (n > 0) {
+    buf[i++] = n % base;
+    n /= base;
+  }
+
+  for (; i > 0; i--)
+    print((char) (buf[i - 1] < 10 ? '0' + buf[i - 1] : 'A' + buf[i - 1] - 10));
+  
+  delay(8);
+  
+}

data/lib/libraries/SWSerLCDpa/SWSerLCDpa.h

@@ -0,0 +1,62 @@
+/*
+  SWSerLCDpa.h - Software serial to Peter Anderson controller chip based
+  LCD display library Adapted from SoftwareSerial.cpp (c) 2006 David A. Mellis
+  by Brian B. Riley, Underhill Center, Vermont, USA, July 2007
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef SWSerLCDpa_h
+#define SWSerLCDpa_h
+
+#include <inttypes.h>
+ 
+class SWSerLCDpa
+{
+  private:
+    uint8_t _transmitPin;
+    long _baudRate;
+    int _bitPeriod;
+    void printNumber(unsigned long, uint8_t);
+  public:
+    SWSerLCDpa(uint8_t);
+    void begin(long);
+    void print(char);
+    void print(const char[]);
+    void print(uint8_t);
+    void print(int);
+    void print(unsigned int);
+    void print(long);
+    void print(unsigned long);
+    void print(long, int);
+    void println(void);
+	void clearscr(void);
+	void home(void);
+	void setgeo(int);
+	void setintensity(int);
+	void intoBignum(void);
+	void outofBignum(void);
+	void setxy(int, int);
+    void println(char);
+    void println(const char[]);
+    void println(uint8_t);
+    void println(int);
+    void println(long);
+    void println(unsigned long);
+    void println(long, int);
+};
+
+#endif
+

data/lib/libraries/SWSerLCDpa/keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+SoftwareSerial	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

data/lib/rad/arduino_sketch.rb

@@ -1,5 +1,116 @@
+# ArduinoSketch is the main access point for working with RAD. Sub-classes of ArduinoSketch have access to a wide array of convenient class methods (documented below) for doing the most common kinds of setup needed when programming the Arduino such as configuring input and output pins and establishing serial connections. Here is the canonical 'hello world' example of blinking a single LED in RAD:
+#
+#   class HelloWorld < ArduinoSketch
+#     output_pin 13, :as => led
+#     
+#     def loop
+#       blink 13, 500
+#     end
+#   end
+#
+# As you can see from this example, your ArduinoSketch sub-class can be dividied into two-parts: class methods for doing configuration and a loop method which will be run repeatedly at the Arduino's clock rate. Documentation for the various available class methods is below. The ArduinoSketch base class is designed to work with a series of rake tasks to automatically translate your loop method into C++ for compilation by the Arduino toolchain (see link://files/lib/rad/tasks/build_and_make_rake.html for details). See http://rad.rubyforge.org/examples for lots more examples of usage.
+#
+# ==Arduino built-in methods
+# Thanks to this translation process you can take advantage of the complete Arduino software API (full docs here: http://www.arduino.cc/en/Reference/HomePage). What follows is the core of a RAD-Arduino dictionary for translating between RAD methods and the Arduino functionality they invoke, N.B. many Arduino methods have been left out (including the libraries for Time, Math, and Random Numbers, as the translation between them and their RAD counterparts should be relatively straightforward after perusing the examples here). For further details on each method, visit their Arduino documenation.
+#
+# <b>Digital I/O</b>
+#
+# digital_write(pin, value)
+#
+#   Arduino method: digitalWrite(pin, value) 
+#
+#   Description: "Ouputs either HIGH or LOW at a specified pin."
+#   
+#   Documentation: http://www.arduino.cc/en/Reference/DigitalWrite
+#   
+# digital_read(pin)
+#
+#   Arduino method: digitalRead(pin) 
+#
+#   Description: "Reads the value from a specified pin, it will be either HIGH or LOW."
+#
+#   Documentation: http://www.arduino.cc/en/Reference/DigitalRead
+# 
+# <b>Analog I/O</b>
+#
+# analog_read(pin) 
+#
+#   Arduino method: analogRead(pin)
+#
+#   Description: "Reads the value from the specified analog pin. The Arduino board contains a 6 channel 
+#     (8 channels on the Mini), 10-bit analog to digital converter. This means that it will map input 
+#     voltages between 0 and 5 volts into integer values between 0 and 1023. This yields a resolution
+#     between readings of: 5 volts / 1024 units or, .0049 volts (4.9 mV) per unit. It takes about 100
+#     us (0.0001 s) to read an analog input, so the maximum reading rate is about 10,000 times a second."
+#
+#   Documentation: http://www.arduino.cc/en/Reference/AnalogRead
+#
+# analog_write(pin, value)
+#
+#   Arduino method: analogWrite(pin, value)
+#
+#   Description: "Writes an analog value (PWM wave) to a pin. On newer Arduino boards (including the Mini
+#     and BT) with the ATmega168 chip, this function works on pins 3, 5, 6, 9, 10, and 11. Older USB and 
+#     serial Arduino boards with an ATmega8 only support analogWrite() on pins 9, 10, and 11. Can be used 
+#     to light a LED at varying brightnesses or drive a motor at various speeds. After a call to analogWrite,
+#     the pin will generate a steady wave until the next call to analogWrite (or a call to digitalRead or 
+#     digitalWrite on the same pin)."
+#
+#   Documentation: http://www.arduino.cc/en/Reference/AnalogWrite
+#
+# <b>Serial Communication</b>
+#
+# serial_available()
+#
+#   Arduino method: Serial.available()
+#   
+#   Description: "Get the number of bytes (characters) available for reading over the serial port. 
+#     Returns the number of bytes available to read in the serial buffer, or 0 if none are 
+#     available. If any data has come in, Serial.available() will be greater than 0. The serial buffer
+#     can hold up to 128 bytes."
+#
+#   Documentation: http://www.arduino.cc/en/Serial/Available
+#
+# serial_read()
+#
+#   Arduino method: Serial.read()
+#
+#   Description: "Reads incoming serial data and returns the first byte of incoming serial data 
+#     available (or -1 if no data is available)"
+#
+#   Documentation: http://www.arduino.cc/en/Serial/Read
+#
+# serial_print(data)
+#
+#   Arduino method: Serial.print(data)
+#
+#   Description: "Prints data to the serial port."
+#
+#   Documentation: http://www.arduino.cc/en/Serial/Print
+#
+# serial_println(data)
+#
+#   Arduino method: Serial.println(data)
+#
+#   Description: "Prints a data to the serial port, followed by a carriage return character 
+#     (ASCII 13, or '\r') and a newline character (ASCII 10, or '\n'). This command takes the 
+#     same forms as Serial.print():"
+#
+#   Documentation: http://www.arduino.cc/en/Serial/Println
+#
+# serial_flush()
+#
+#   Arduino method: Serial.flush()
+#
+#   Description: "Flushes the buffer of incoming serial data. That is, any call to Serial.read() 
+#     or Serial.available() will return only data received after the most recent call 
+#     to Serial.flush()."
+#
+#   Documentation: http://www.arduino.cc/en/Serial/Flush
+#
 class ArduinoSketch
-  def initialize
+  
+  def initialize #:nodoc:
     @declarations = []
     @pin_modes = {:output => [], :input => []}
     @pullups = []
@@ -18,6 +129,7 @@ class ArduinoSketch
     @helper_methods = helper_methods.join( "\n" )
   end
   
+  # Setup variables outside of the loop. Does some magic based on type of arguments. Subject to renaming. Use with caution.
   def vars(opts={})
     opts.each do |k,v|
       if v.class == Symbol
@@ -38,7 +150,7 @@ class ArduinoSketch
         when FalseClass
           "bool"
         end
-        #vars need to be underscored...accessors not
+
         @declarations << "#{type} _#{k} = #{v};"
         @accessors << <<-CODE
           #{type} #{k}(){
@@ -49,6 +161,17 @@ class ArduinoSketch
     end
   end
   
+  # Confiugre a single pin for output and setup a method to refer to that pin, i.e.:
+  #
+  #   output_pin 7, :as => :led
+  #
+  # would configure pin 7 as an output and let you refer to it from the then on by calling
+  # the `led` method in your loop like so:
+  # 
+  #   def loop
+  #     digital_write led, ON
+  #   end
+  #
   def output_pin(num, opts={})
     raise ArgumentError, "can only define pin from Fixnum, got #{num.class}" unless num.is_a?(Fixnum)
     @pin_modes[:output] << num
@@ -65,11 +188,23 @@ class ArduinoSketch
     end
   end
   
+  # Like ArduinoSketch#output_pin but configure more than one output pin simultaneously. Takes an array of pin numbers. 
   def output_pins(nums)
     ar = Array(nums)
     ar.each {|n| output_pin(n)} 
   end
   
+  # Confiugre a single pin for input and setup a method to refer to that pin, i.e.:
+  #
+  #   input_pin 3, :as => :button
+  #
+  # would configure pin 3 as an input and let you refer to it from the then on by calling
+  # the `button` method in your loop like so:
+  # 
+  #   def loop
+  #     digital_write led if digital_read button
+  #   end
+  #
   def input_pin(num, opts={})
     raise ArgumentError, "can only define pin from Fixnum, got #{num.class}" unless num.is_a?(Fixnum)
     @pin_modes[:input] << num
@@ -87,24 +222,34 @@ class ArduinoSketch
     @pullups << num if opts[:as]
   end
   
+  # Like ArduinoSketch#input_pin but configure more than one input pin simultaneously. Takes an array of pin numbers. 
   def input_pins(nums)
     ar = Array(nums)
     ar.each {|n| input_pin(n)} 
   end
   
-  def add(st)
+  def add(st) #:nodoc:
     @helper_methods << "\n#{st}\n"
   end
   
+  # Configure Arduino for serial communication. Optionally, set the baud rate:
+  #
+  #   serial_begin :rate => 2400
+  #
+  # default is 9600. See http://www.arduino.cc/en/Serial/Begin for more details.
+  # 
   def serial_begin(opts={})
     rate = opts[:rate] ? opts[:rate] : 9600
     @other_setup << "Serial.begin(#{rate});"
   end
   
+  # Treat a pair of digital I/O pins as a serial line. See: http://www.arduino.cc/en/Tutorial/SoftwareSerial
  	def software_serial(rx, tx, opts={})
     raise ArgumentError, "can only define rx from Fixnum, got #{rx.class}" unless rx.is_a?(Fixnum)
     raise ArgumentError, "can only define tx from Fixnum, got #{tx.class}" unless tx.is_a?(Fixnum)
     
+    output_pin(tx)
+    
     rate = opts[:rate] ? opts[:rate] : 9600
  		if opts[:as]
  			@declarations << "SoftwareSerial _#{opts[ :as ]} = SoftwareSerial(#{rx}, #{tx});"
@@ -134,14 +279,110 @@ class ArduinoSketch
  			@other_setup << "_#{opts[ :as ]}.begin(#{rate});"
  		end
  	end 	
+ 	
+ 	def swser_LCDpa(tx, opts={})
+    raise ArgumentError, "can only define tx from Fixnum, got #{tx.class}" unless tx.is_a?(Fixnum)
+    output_pin(tx)
+    
+    rate = opts[:rate] ? opts[:rate] : 9600
+ 		if opts[:as]
+ 			@declarations << "SWSerLCDpa _#{opts[ :as ]} = SWSerLCDpa(#{tx});"
+ 			accessor = []
+ 			accessor << "SWSerLCDpa& #{opts[ :as ]}() {"
+ 			accessor << "\treturn _#{opts[ :as ]};"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, uint8_t b ) {"
+ 			accessor << "\treturn s.print( b );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, const char *str ) {"
+ 			accessor << "\treturn s.print( str );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, char c ) {"
+ 			accessor << "\treturn s.print( c );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, int i ) {"
+ 			accessor << "\treturn s.print( i );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, unsigned int i ) {"
+ 			accessor << "\treturn s.print( i );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, long i ) {"
+ 			accessor << "\treturn s.print( i );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, unsigned long i ) {"
+ 			accessor << "\treturn s.print( i );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, long i, int b ) {"
+ 			accessor << "\treturn s.print( i, b );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, char* str ) {"
+ 			accessor << "\treturn s.println( str );"
+ 			accessor << "}"
+ 			accessor << "void print( SWSerLCDpa& s, char* str ) {"
+ 			accessor << "\treturn s.print( str );"
+ 			accessor << "}"
+ 			accessor << "void println(SWSerLCDpa& s) {"
+ 			accessor << "\treturn s.println();"
+ 			accessor << "}"
+ 			accessor << "void clearscr(SWSerLCDpa& s) {"
+ 			accessor << "\treturn s.clearscr();"
+ 			accessor << "}"
+ 			accessor << "void home(SWSerLCDpa& s) {"
+ 			accessor << "\treturn s.home();"
+ 			accessor << "}"
+ 			accessor << "void setgeo( SWSerLCDpa& s, int i ) {"
+ 			accessor << "\treturn s.setgeo( i );"
+ 			accessor << "}"
+ 			accessor << "void setintensity( SWSerLCDpa& s, int i ) {"
+ 			accessor << "\treturn s.setintensity( i );"
+ 			accessor << "}"
+ 			accessor << "void intoBignum(SWSerLCDpa& s) {"
+ 			accessor << "\treturn s.intoBignum();"
+ 			accessor << "}"
+ 			accessor << "void outofBignum(SWSerLCDpa& s) {"
+ 			accessor << "\treturn s.outofBignum();"
+ 			accessor << "}"
+ 			accessor << "void setxy( SWSerLCDpa& s, int x, int y) {"
+ 			accessor << "\treturn s.setxy( x, y );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, char c ) {"
+ 			accessor << "\treturn s.println( c );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, const char c[] ) {"
+ 			accessor << "\treturn s.println( c );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, uint8_t b ) {"
+ 			accessor << "\treturn s.println( b );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, int i ) {"
+ 			accessor << "\treturn s.println( i );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, long i ) {"
+ 			accessor << "\treturn s.println( i );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, unsigned long i ) {"
+ 			accessor << "\treturn s.println( i );"
+ 			accessor << "}"
+ 			accessor << "void println( SWSerLCDpa& s, long i, int b ) {"
+ 			accessor << "\treturn s.println( i, b );"
+ 			accessor << "}"
+ 			@accessors << accessor.join( "\n" )
+ 			
+ 			@signatures << "SWSerLCDpa& #{opts[ :as ]}();"
+ 
+ 			@other_setup << "_#{opts[ :as ]}.begin(#{rate});"
+ 		end
+ 	end 	
   
-  def compose_setup # also composes headers and signatures
+  def compose_setup #:nodoc: also composes headers and signatures
     result = []
     
     result << comment_box( "Auto-generated by RAD" )
     
     result << "#include <WProgram.h>\n"
     result << "#include <SoftwareSerial.h>\n"
+    result << "#include <SWSerLCDpa.h>"
+
     
     result << comment_box( 'method signatures' )
     result << "void loop();"
@@ -203,8 +444,10 @@ class ArduinoSketch
     return result.join( "\n" )
   end
   
-  def assembler(name, declaration, code)
-    @assembler_declarations << declaration
+  
+  # Write inline assembler code. 'Name' is a symbol representing the name of the function to be defined in the assembly code; 'signature' is the function signature for the function being defined; and 'code' is the assembly code itself (both of these last two arguments are strings). See an example here: http://rad.rubyforge.org/examples/assembler_test.html
+  def assembler(name, signature, code)
+    @assembler_declarations << signature
     assembler_code = <<-CODE
       .file "#{name}.S"
       .arch #{Makefile.hardware_params['mcu']}
@@ -219,7 +462,7 @@ class ArduinoSketch
     File.open(File.expand_path("#{RAD_ROOT}") + "/#{PROJECT_DIR_NAME}/#{name}.S", "w"){|f| f << assembler_code}
   end
   
-  def self.pre_process(sketch_string)
+  def self.pre_process(sketch_string) #:nodoc:
     result = sketch_string
     result.gsub!("HIGH", "1")
     result.gsub!("LOW", "0")
@@ -230,7 +473,7 @@ class ArduinoSketch
   
   private
   
-  def serial_boilerplate
+  def serial_boilerplate #:nodoc:
     out = []
     out << "int serial_available() {"
     out << "\treturn (Serial.available() > 0);"
@@ -271,7 +514,7 @@ class ArduinoSketch
     return out.join( "\n" )
   end
   
-  def comment_box( content )
+  def comment_box( content ) #:nodoc:
     out = []
     out << "/" * 74
     out << "// " + content

data/lib/rad/generators/makefile/makefile.erb

@@ -64,11 +64,12 @@ PORT = <%= params['serial_port'] %>
 TARGET = <%= params['target'] %>
 ARDUINO = <%= params['arduino_root'] %>/hardware/cores/arduino
 SOFTWARE_SERIAL = <%= params['arduino_root'] %>/hardware/libraries/SoftwareSerial
+LIBRARY_ROOT = <%= params['libraries_root'] %>
 SRC = $(ARDUINO)/pins_arduino.c $(ARDUINO)/wiring.c \
 $(ARDUINO)/wiring_analog.c $(ARDUINO)/wiring_digital.c \
 $(ARDUINO)/wiring_pulse.c $(ARDUINO)/wiring_serial.c \
 $(ARDUINO)/wiring_shift.c $(ARDUINO)/WInterrupts.c
-CXXSRC = $(ARDUINO)/HardwareSerial.cpp $(ARDUINO)/WRandom.cpp $(SOFTWARE_SERIAL)/SoftwareSerial.cpp
+CXXSRC = $(ARDUINO)/HardwareSerial.cpp $(ARDUINO)/WRandom.cpp $(SOFTWARE_SERIAL)/SoftwareSerial.cpp<%= params['libraries'].collect{|l| " $(LIBRARY_ROOT)/#{ l }/#{l }.cpp"}.join('') %>
 MCU = <%= params['mcu'] %>
 <% if params['asm_files'] %>ASRC = <%= params['asm_files'].join(' ') %><% end %>
 F_CPU = 16000000
@@ -91,8 +92,8 @@ CDEFS = -DF_CPU=$(F_CPU)
 CXXDEFS = -DF_CPU=$(F_CPU)
 
 # Place -I options here
-CINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)
-+CXXINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)
+CINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)<% params['libraries'].each do |l| %> -I$(LIBRARY_ROOT)/<%= l %><% end %>
++CXXINCS = -I$(ARDUINO) -I$(SOFTWARE_SERIAL)<% params['libraries'].each do |l| %> -I$(LIBRARY_ROOT)/<%= l %><% end %>
 
 # Compiler flag to set the C Standard level.
 # c89   - "ANSI" C

data/lib/rad/generators/makefile/makefile.rb

@@ -1,4 +1,5 @@
 require 'erb'
+require 'yaml'
 
 class Makefile
   class << self
@@ -8,6 +9,9 @@ class Makefile
       params = hardware_params.merge software_params
       params['target'] = sketch_name
       
+      params['libraries_root'] = "#{File.expand_path(RAD_ROOT)}/vendor/libraries"
+      params['libraries'] = libraries
+      
       params['asm_files'] = Dir.entries( File.expand_path(RAD_ROOT) + "/" + PROJECT_DIR_NAME ).select{|e| e =~ /\.S/}            
             
       e = ERB.new File.read("#{File.dirname(__FILE__)}/makefile.erb")
@@ -17,6 +21,10 @@ class Makefile
       end
     end
     
+    def libraries
+      Dir.entries("#{RAD_ROOT}/vendor/libraries").select{|e| !(e =~ /\./)}
+    end
+    
     def hardware_params
       return @hardware_params if @hardware_params
       return @hardware_params = YAML.load_file( "#{RAD_ROOT}/config/hardware.yml")

data/lib/rad/todo.txt

@@ -1,18 +1,13 @@
-# TODO
-
--prep for gem distribution and Rails-style installation
-
--full Arduino lib support!
--add if_newer? stuff to Rakefile for efficiency
--support for custom methods (instance vs. class methods?)
--helper hello world (blink)
-
--use definitions on different function signatures to implement smart read and write
-
-#Complaints about RubyToC
--methods can't take arguments with defaults!
--can't raise errors!
-
-#Syntax wishlist
--read should have a default on mode
--write should be able to calculate its mode from the class of its value
+TODO:
+=====
+	
+Future:
+	- complete library system: script/install library some_library
+	- bin/rad:
+		- setup and use a ~/.rad for new project defaults
+	- put repository on git
+	- project gallery (examples with movies)
+	- testing framework
+	- implement wire lib
+	- subclasses of ArduinoSketch (should just work, but what are they for?)
+	- simulator

data/lib/rad/version.rb

@@ -2,7 +2,7 @@ module Rad #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

metadata

@@ -1,33 +1,40 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: rad
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2008-03-16 00:00:00 -07:00
-summary: A framework for programming the Arduino physcial computing platform using Ruby. RAD converts Ruby scripts written using a set of Rails-like conventions and helpers into C source code which can be compiled and run on the Arduino microcontroller.
-require_paths: 
-- lib
-email: greg@mfdz.com
-homepage: http://rad.rubyforge.org
-rubyforge_project: rad
-description: A framework for programming the Arduino physcial computing platform using Ruby. RAD converts Ruby scripts written using a set of Rails-like conventions and helpers into C source code which can be compiled and run on the Arduino microcontroller.
-autorequire: 
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.2.1
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Greg Borenstein
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: RubyToC
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
+description: A framework for programming the Arduino physcial computing platform using Ruby. RAD converts Ruby scripts written using a set of Rails-like conventions and helpers into C source code which can be compiled and run on the Arduino microcontroller.
+email: greg@mfdz.com
+executables: 
+- rad
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- lib/libraries/SWSerLCDpa/keywords.txt
+- lib/rad/todo.txt
+- website/index.txt
 files: 
 - History.txt
 - License.txt
@@ -35,6 +42,9 @@ files:
 - README.txt
 - Rakefile
 - bin/rad
+- lib/libraries/SWSerLCDpa/keywords.txt
+- lib/libraries/SWSerLCDpa/SWSerLCDpa.cpp
+- lib/libraries/SWSerLCDpa/SWSerLCDpa.h
 - lib/rad.rb
 - lib/rad/arduino_sketch.rb
 - lib/rad/init.rb
@@ -54,31 +64,32 @@ files:
 - website/javascripts/rounded_corners_lite.inc.js
 - website/stylesheets/screen.css
 - website/template.rhtml
-test_files: []
-
+has_rdoc: true
+homepage: http://rad.rubyforge.org
+post_install_message: 
 rdoc_options: 
 - --main
 - README.txt
-extra_rdoc_files: 
-- History.txt
-- License.txt
-- Manifest.txt
-- README.txt
-- lib/rad/todo.txt
-- website/index.txt
-executables: 
-- rad
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: RubyToC
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.0.0
-    version: 
+rubyforge_project: rad
+rubygems_version: 1.1.0
+signing_key: 
+specification_version: 2
+summary: A framework for programming the Arduino physcial computing platform using Ruby. RAD converts Ruby scripts written using a set of Rails-like conventions and helpers into C source code which can be compiled and run on the Arduino microcontroller.
+test_files: []
+