madrona-rad 0.2.7 → 0.3.1

data/lib/plugins/blink.rb

@@ -0,0 +1,25 @@
+class Blink < ArduinoPlugin
+  
+  # RAD plugins are c methods, directives, external variables and assignments and calls 
+  # that may be added to the main setup method
+  # function prototypes not needed since we generate them automatically
+  
+  # directives, external variables and setup assignments and calls can be added rails style (not c style)
+
+
+  # add to directives
+ 
+  # add to external variables
+ 
+  # add the following to the setup method
+  # add_to_setup 
+
+
+  void blink(int pin, int ms) {
+  	digitalWrite( pin, HIGH );
+  	delay( ms );
+  	digitalWrite( pin, LOW );
+  	delay( ms );
+  }
+
+end

data/lib/plugins/blink_m.rb

@@ -49,7 +49,7 @@ static void BlinkM_beginWithPowerPins(byte pwrpin, byte gndpin)
 }
 
 // Call this first when BlinkM is plugged directly into Arduino
-// The BlinkM's PWR (power) pins should line up with pins 2 and 3 of the connector, 
+// The BlinkMs PWR (power) pins should line up with pins 2 and 3 of the connector, 
 // while the I2C (communications) pins should line up with pins 4 and 5.
 
 static void BlinkM_beginWithPower()
@@ -134,7 +134,7 @@ static int BlinkM_getVersion(byte addr)
     return -1;
 }
 
-// Demonstrates how to verify you're talking to a BlinkM 
+// Demonstrates how to verify you-re talking to a BlinkM 
 // and that you know its address -- message version
 
 static char* blink_m_check_address_message(byte addr) // :as => :optional
@@ -158,7 +158,7 @@ static char* blink_m_check_address_message(byte addr) // :as => :optional
         return strcat(message, status); // match, everything okay
 }
 
-// Demonstrates how to verify you're talking to a BlinkM 
+// Demonstrates how to verify you-re talking to a BlinkM 
 // and that you know its address -- digital version
 
 static int BlinkM_checkAddress(byte addr)

data/lib/plugins/lcd_padding.rb

@@ -35,5 +35,24 @@ static char* pad_int_to_str(int num, int length)
     return pretty;
 }
 
+static char* pad_int_to_str_w_zeros(int num, int length) 
+{
+    int i = 0;
+    int start;
+    char plain[20];
+    char space[5] = "0 ";    
+    char* pretty = "        ";    
+    itoa(num, plain ,10);
+    start = length - strlen(plain);
+    while (i <= length) {
+      if (i >= start)
+        pretty[i] = plain[i - start];       
+      else
+        pretty[i] = space[0];
+      i++;
+    }
+    return pretty;
+}
+
 
 end

data/lib/plugins/midi.rb

@@ -0,0 +1,60 @@
+class Midi < ArduinoPlugin
+ 
+ 
+# reference 
+  
+# To send MIDI, attach a MIDI out jack (female DIN-5) to Arduino.
+# DIN-5 pinout is:                               _____ 
+#    pin 2 - Gnd                                /     \
+#    pin 4 - 220 ohm resistor to +5V           | 3   1 |  Female MIDI jack 
+#    pin 5 - Arduino D1 (TX)                   |  5 4  |
+#    all other pins - unconnected               \__2__/
+#  Adapted from Tom Igoe's work at:
+#   http://itp.nyu.edu/physcomp/Labs/MIDIOutput
+#  And Tod E. Kurt <tod@todbot.com
+#   http://todbot.com/
+#
+#  Created 25 October 2008
+#  copyleft 2008 jdbarnhart 
+#  http://jdbarnhart.com/
+  
+void note_on(char cmd, int data1, char data2) {
+  Serial.print(cmd, BYTE);
+  Serial.print(data1, BYTE);
+  Serial.print(data2, BYTE);
+}
+  
+void note_on(int channel, int note, int velocity) {
+  midi_msg( (0x90 | (channel)), note, velocity);
+}
+
+void note_on(long int& channel, long int& note, long int& velocity) {
+  midi_msg( (0x90 | (channel)), note, velocity);
+}
+
+void note_off(long int& channel, long int& note, long int& velocity) {
+  midi_msg( (0x90 | (channel)), note, velocity);
+}
+
+void note_off(byte channel, byte note, byte velocity) {
+  midi_msg( (0x90 | (channel)), note, velocity);
+}
+
+void play_note(long int& channel, long int& note, long int& velocity) {
+  midi_msg( (0x90 | (channel)), note, velocity);
+  delay(100);
+  midi_msg( (0x90 | (channel)), note, 0);
+}
+
+
+
+void midi_msg(byte cmd, byte data1, byte data2) {
+  digitalWrite(led(), 1); // indicate we're sending MIDI data
+  Serial.print(cmd, BYTE);
+  Serial.print(data1, BYTE);
+  Serial.print(data2, BYTE);
+  digitalWrite(led(), 0); // indicate we're sending MIDI data
+}
+
+
+end

data/lib/plugins/parallax_ping.rb

@@ -0,0 +1,50 @@
+class ParallaxPing < ArduinoPlugin
+
+  # RAD plugins are c methods, directives, external variables and assignments and calls 
+  # that may be added to the main setup method
+  # function prototypes not needed since we generate them automatically
+  
+  # directives, external variables and setup assignments and calls can be added rails style (not c style)
+
+  # add to directives
+  # plugin_directives "#define EXAMPLE 10"
+
+  # add to external variables
+  # external_variables "int foo, bar"
+
+  # add the following to the setup method
+  # add_to_setup "foo = 1";, "bar = 1;" "sub_setup();"
+  
+  # one or more methods may be added and prototypes are
+  
+  # Methods for the Parallax Ping)) UltraSonic Distance Sensor.
+  # 
+  # Example:
+  #
+  # class RangeFinder < ArduinoSketch
+  #   serial_begin
+  #   
+  #   external_vars :sig_pin => 'int, 7'
+  #   
+  #   def loop
+  #     serial_println(ping(sig_pin)) 
+  #     delay(200) 
+  #   end
+  # end
+
+  # Triggers a pulse and returns the delay in microseconds for the echo.
+  int ping(int pin) {
+    pinMode(pin, OUTPUT);
+
+    digitalWrite(pin, LOW);
+    delayMicroseconds(2);
+    digitalWrite(pin, HIGH);
+    delayMicroseconds(5);
+    digitalWrite(pin, LOW);
+
+    pinMode(pin, INPUT);
+
+    return pulseIn(pin, HIGH);
+  }
+
+end

data/lib/plugins/servo_setup.rb

@@ -59,7 +59,7 @@ void move_servo(int servo_num, int pulse_width)
     {
       pulse_servo(servo_name.pin, pw);
       servo_name.lastPulse = millis();
-      if (find_total_loop_time() < 10)
+      // if (find_total_loop_time() < 10)
       // for debug:
       // digitalWrite( 5, HIGH );
       // 18 seems optimal, but we should let the users adjust with a servo option

data/lib/plugins/twitter_connect.rb

@@ -0,0 +1,145 @@
+class TwitterConnect < ArduinoPlugin
+
+
+
+
+void get_tweet() {
+  // hack to pull 
+}
+
+uint32_t parsenumber(char *str) {
+  uint32_t num = 0;
+  char c;
+  
+  // grabs a number out of a string
+  while (c = str[0]) {
+   if ((c < '0') || (c > '9'))
+     return num;
+   num *= 10;
+   num += c - '0';
+   str++;
+ }
+ return num;
+}
+
+
+char * fetchtweet(void) {
+  Serial.print("... fetching tweets....");
+  uint8_t ret;
+  char *found=0, *start=0, *end=0;
+  
+  tweet[0] = 0;  // reset the tweet
+  ret = xport.reset();
+  //Serial.print("Ret: "); Serial.print(ret, HEX);
+  switch (ret) {
+   case  ERROR_TIMEDOUT: { 
+      Serial.println("Timed out on reset!"); 
+      return 0;
+   }
+   case ERROR_BADRESP:  { 
+      Serial.println("Bad response on reset!");
+      return 0;
+   }
+   case ERROR_NONE: { 
+    Serial.println("Reset OK!");
+    break;
+   }
+   default:
+     Serial.println("Unknown error"); 
+     return 0;
+  }
+  
+  // time to connect...
+ 
+  ret = xport.connect(IPADDR, PORT);
+    switch (ret) {
+   case  ERROR_TIMEDOUT: { 
+      Serial.println("Timed out on connect"); 
+      return 0;
+   }
+   case ERROR_BADRESP:  { 
+      Serial.println("Failed to connect");
+      return 0;
+   }
+   case ERROR_NONE: { 
+     Serial.println("Connected..."); break;
+   }
+   default:
+     Serial.println("Unknown error"); 
+     return 0;
+  }
+  
+  // send the HTTP command, ie "GET /username/"
+  
+    xport.print("GET "); xport.println(HTTPPATH);
+// the following works with instiki, but not on twitter...
+//  xport.print("GET "); 
+//  xport.print(HTTPPATH);
+//  xport.println(" HTTP/1.1");
+//  xport.print("Host: "); xport.println(HOSTNAME);
+//  xport.println("");
+    
+  
+
+  while (1) {
+    // read one line from the xport at a time
+    ret = xport.readline_timeout(linebuffer, 255, 4000); // 3s timeout
+    // if we're using flow control, we can actually dump the line at the same time!
+    // Serial.print(linebuffer);
+    
+    // look for an entry (the first one)
+    found = strstr(linebuffer, "entry-title entry-content");
+    if (((int)found) != 0) {
+      start = strstr(found, ">") + 1;
+      end = strstr(found, "</p>");
+      if ((start != 0) && (end != 0)) {
+        Serial.println("\n******Found first entry!*******");
+        end[0] = 0;
+        Serial.print(start);
+        // save the tweet so we can display it later
+        strncpy(tweet, start, TWEETLEN);
+        tweet[TWEETLEN-1] = 0;
+      }
+    }
+    
+    // next we look for a status ID (which should correspond to the previous tweet)e
+    // Serial.print(".");
+    // Serial.print(linebuffer);
+    found = strstr(linebuffer, "<div id=\"status_actions_");  
+    if (((int)found) != 0) {
+      start =  found + 25; // strlen("<span id=\"status_actions_")
+      end = strstr(found, "\">");
+      if ((start != 0) && (end != 0)) {
+        Serial.println("\n******Found status ID!*******");
+        end[0] = 0;
+        Serial.println(start);
+        // turn the string into a number
+        __currstatus = parsenumber(start);
+        Serial.println(__currstatus, DEC);
+        
+        // check if this is a nu tweet
+        if (__currstatus > __laststatus) {
+           __laststatus = __currstatus;
+           Serial.println("New message");
+           Serial.print(tweet);
+        } else {
+          tweet[0] = 0;
+        }
+       // flush the conn
+       xport.flush(5000); // 5 second timeout
+ 
+       if (tweet[0] == 0) { return 0; }
+       else {return tweet; }
+      }
+    }
+    
+    if (((__errno == ERROR_TIMEDOUT) && xport.disconnected()) ||
+        ((XPORT_DTRPIN == 0) &&
+         (linebuffer[0] == 'D') && (linebuffer[1] == 0)))  {
+       Serial.println("\nDisconnected...");
+       return 0;
+    }
+  }
+}
+
+end

data/lib/rad/README.rdoc

@@ -0,0 +1,5 @@
+=Welcome to RAD (Ruby Arduino Development) Quick Start Documentation
+
+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:
+
+test... to be continued if it works..

data/lib/rad/arduino_sketch.rb

@@ -157,8 +157,9 @@ class ArduinoSketch
   include ExternalVariableProcessing
   
   # find another way to do this
-  @@frequency_inc = FALSE
-  @@twowire_inc	= FALSE
+  @@twowire_inc	  = FALSE
+  @@hwserial_inc  = FALSE
+
   
   def initialize #:nodoc:
     @servo_settings = [] # need modular way to add this
@@ -177,7 +178,7 @@ class ArduinoSketch
     $defines  ||= []
     $define_types = {}
     $array_types = {}
-    $array_index_helpers = ('a'..'zz').to_a
+    $array_index_helpers ||= ('a'..'zzz').to_a
 
     @declarations = []
     @pin_modes = {:output => [], :input => []}
@@ -185,194 +186,77 @@ class ArduinoSketch
     @other_setup = [] # specifically, Serial.begin
     @assembler_declarations = []
     @accessors = []
-    @signatures = ["void blink();", "int main();", "void track_total_loop_time(void);", "unsigned long find_total_loop_time(void);"]
-
+    @signatures = ["int main();"]
+ 
     helper_methods = []
-    helper_methods << "void blink(int pin, int ms) {"
-    helper_methods << "\tdigitalWrite( pin, HIGH );"
-    helper_methods << "\tdelay( ms );"
-    helper_methods << "\tdigitalWrite( pin, LOW );"
-    helper_methods << "\tdelay( ms );"
-    helper_methods << "}"
-    helper_methods << "void track_total_loop_time(void)"
-    helper_methods << "{"
-    helper_methods << "\ttotal_loop_time = millis() - start_loop_time;"
-    helper_methods << "\tstart_loop_time = millis();"
-    helper_methods << "}"
-    helper_methods << "unsigned long find_total_loop_time(void)"
-    helper_methods << "{"
-    helper_methods << "\nreturn total_loop_time;"
-    helper_methods << "}"
     @helper_methods = helper_methods.join( "\n" )
-    
-    @declarations << "unsigned long start_loop_time = 0;"
-    @declarations << "unsigned long total_loop_time = 0;"
+
   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
-       @declarations << "#{v} _#{k};"
-       @accessors << <<-CODE
-        #{v} #{k}(){
-        \treturn _#{k};
-        }
-       CODE
-      else
-        type = case v
-        when Integer
-          "int"
-        when String
-          "char*"
-        when TrueClass
-          "bool"
-        when FalseClass
-          "bool"
-        end
 
-        @declarations << "#{type} _#{k} = #{v};"
-        @accessors << <<-CODE
-          #{type} #{k}(){
-          \treturn _#{k};
-          }
-        CODE
-      end
+  
+  # array "char buffer[32]"
+  # result: char buffer[32];
+  # array "char buffer[32]"
+  # result: char buffer[32];
+  # todo 
+  # need to feed array external array identifiers to rtc if they are in plugins or libraries, (not so sure about this will do more testing)
+  def array(arg)
+    if arg
+        arg = arg.chomp.rstrip.lstrip
+        arg.sub!("@","__")
+        name = arg.scan(/\s*(\w*)\[\d*\]?/).first.first
+        # help rad_processor do a better job with array types
+        types = ["int", "long", "char*", "unsigned int", "unsigned long", "byte", "bool", "float" ]
+        types.each_with_index do |type, i|
+          @type = types[i] if /#{type}/ =~ arg
+        end
+        raise ArgumentError, "type not currently supported.. got: #{arg}.  Currently supporting #{types.join(", ")}" unless @type
+
+        arg = "#{arg};" unless arg[-1,1] == ";"
+        $array_types[name] = @type
+        @type = nil
+        $external_var_identifiers << name unless $external_var_identifiers.include?(name)
+        # add array_name declaration
+        $external_array_vars << arg unless $external_array_vars.include?(arg)
     end
   end
   
-
-    # a different way to setup external variables outside the loop
-    # 
-    # in addition to being added to the c file as external variables:
-    # we fake ruby2c out by adding them to internal vars for ruby2c processing
-    # but we don't include then in the cpp loop
-    # then, we use the indentiers to remove any parens that ruby2c adds 
-    # this resolves ruby2c's habit of converting variables to methods
-    # need tests and ability to add custom char length
-    def external_vars(opts={})
-      if opts
-          opts.each do |k,v|
-            if v.include? ","
-              if v.split(",")[0] == "char"
-                ## default is 40 characters
-                if v.split(",")[2]
-                    $external_vars << "#{v.split(",")[0]}* #{k}[#{v.split(",")[2].lstrip}];"
-                else
-                    $external_vars << "#{v.split(",")[0]} #{k}[40] = \"#{v.split(",")[1].lstrip}\";"
-                end
-              else
-              $external_vars << "#{v.split(",")[0]} #{k} =#{v.split(",")[1]};"
-              end
-            else
-              if v.split(",")[0] == "char"
-                $external_vars << "#{v.split(",")[0]} #{k}[40];"
-              else
-
-                $external_vars << "#{v.split(",")[0]} #{k};"
-              end
-            end
-            # check chars work here
-            $external_var_identifiers << k
-         end
-      end
-    end
-
-    # phasing this out
-    def add_to_setup(*args)
-      if args
-         args.each do |arg|
-           $add_to_setup << arg
+  # define "DS1307_SEC 0"
+  # result: #define DS1307_SEC 0
+  # note we send the constant identifiers and type to our rad_type_checker
+  # however, it only knows about long, float, str....
+  # so we don't send ints ...yet..
+  # need more testing
+  def define(arg)
+    if arg
+        arg = arg.chomp.rstrip.lstrip
+        name = arg.split(" ").first
+        value = arg.gsub!("#{name} ","")
+        # negative
+        if value =~ /^-(\d|x)*$/ 
+           type = "long"
+         # negative float
+         elsif value =~ /^-(\d|\.|x)*$/ 
+           type = "float" 
+         elsif value =~ /[a-zA-Z]/
+           type = "str"
+           value = "\"#{value}\""
+         elsif value !~ /(\.|x)/
+           type = "long"
+         elsif value =~ /(\d*\.\d*)/ # and no 
+           type = "float"
+         elsif value =~ /0x\d\d/
+           type = "byte"
+         else 
+           raise ArgumentError, "opps, could not determine the define type, got #{value}"
          end
-       end
-    end
-
-    # phasing this out
-    def external_arrays(*args)
-      if args
-        args.each do |arg|
-          $external_array_vars << arg
-        end
-      end
-
-    end
-    
-    # array "char buffer[32]"
-    # result: char buffer[32];
-    # array "char buffer[32]"
-    # result: char buffer[32];
-    # todo 
-    # need to feed array external array identifiers to rtc if they are in plugins or libraries, (not so sure about this will do more testing)
-    def array(arg)
-      if arg
-          arg = arg.chomp.rstrip.lstrip
-          name = arg.scan(/\s*(\w*)\[\d*\]?/).first.first
-          
-    # following 10 lines seem to be unnecessary
-    # and are left over from early array work
-    # but they are still here for a bit
-    # determine if there is an array assignement, and how many
-    # then eliminate the assignment and update the array size
-    #      if /\w*\[\d*\]\s*\=\s*\{(.*)\}/ =~ arg
-    #        assignment = arg.scan(/\w*\[\d*\]\s*\=\s*\{(.*)\}/).first.first
-    #        array_size = assignment.split(",").length
-    #        if /\[(\s*)\]/ =~ arg
-    #          arg.gsub!(/(\[\d*\])/, "[#{array_size}]")
-    #        end
-    #      end
-    #      arg = arg.scan(/^((\s*|\w*)*\s*\w*\[\d*\])?/).first.first
-
-          # help rad_processor do a better job with array types
-          types = ["int", "long", "char*", "unsigned int", "unsigned long", "byte", "bool", "float" ]
-          types.each_with_index do |type, i|
-            @type = types[i] if /#{type}/ =~ arg
-          end
-          raise ArgumentError, "type not currently supported.. got: #{arg}.  Currently supporting #{types.join(", ")}" unless @type
-
-          arg = "#{arg};" unless arg[-1,1] == ";"
-          $array_types[name] = @type
-          @type = nil
-          $external_var_identifiers << name unless $external_var_identifiers.include?(name)
-          # add array_name declaration
-          $external_array_vars << arg unless $external_array_vars.include?(arg)
-      end
-    end
-    
-    # define "DS1307_SEC 0"
-    # result: #define DS1307_SEC 0
-    # note we send the constant identifiers and type to our rad_type_checker
-    # however, it only knows about long, float, str....
-    # so we don't send ints ...yet..
-    # need more testing
-    def define(arg)
-      if arg
-          arg = arg.chomp.rstrip.lstrip
-          name = arg.split(" ").first
-          value = arg.gsub!("#{name} ","")
-          # negative
-          if value =~ /^-(\d|x)*$/ 
-             type = "long"
-           # negative float
-           elsif value =~ /^-(\d|\.|x)*$/ 
-             type = "float" 
-           elsif value =~ /[a-zA-Z]/
-             type = "str"
-             value = "\"#{value}\""
-           elsif value !~ /(\.|x)/
-             type = "long"
-           elsif value =~ /(\d*\.\d*)/ # and no 
-             type = "float"
-           elsif value =~ /0x\d\d/
-             type = "byte"
-           else 
-             raise ArgumentError, "opps, could not determine the define type, got #{value}"
-           end
-          $define_types[name] = type
-          arg = "#define #{name} #{value}"
-          $defines << arg
-          dummy_for_testing = arg, type
-      end
+        $define_types[name] = type
+        arg = "#define #{name} #{value}"
+        $defines << arg
+        dummy_for_testing = arg, type
     end
+  end
   
   # Configure a single pin for output and setup a method to refer to that pin, i.e.:
   #
@@ -392,13 +276,8 @@ class ArduinoSketch
       if opts[:device]
         case opts[:device]
         when :servo
-          new_servo_setup(num, opts)
+          servo_setup(num, opts)
           return # don't use declarations, accessor, signatures below
-        when :orig_servo
-          orig_servo_setup(num, opts)
-        when :lcd || :LCD
-          lcd_setup(num, opts)
-          return 
         when :pa_lcd || :pa_LCD
           pa_lcd_setup(num, opts)
           return 
@@ -413,6 +292,7 @@ class ArduinoSketch
           return #
         when :i2c_eeprom
           two_wire(num, opts) unless @@twowire_inc
+          i2c_eeprom(num, opts)
           return #
         when :i2c_ds1307
           two_wire(num, opts) unless @@twowire_inc
@@ -425,24 +305,12 @@ class ArduinoSketch
         when :onewire
           one_wire(num, opts)
           return #
+        when :ethernet
+          ethernet(num, opts)
+          return #
         else
-          raise ArgumentError, "today's device choices are: :servo, :original_servo_setup, :pa_lcd, :sf_lcd, :freq_out,:i2c, :i2c_eeprom, :i2c_ds1307, and :i2c_blinkm  got #{opts[:device]}"
-        end
-      end
-    
-# remove the next 14 lines as soon as documentation on new :device => :servo option is out
-      
-      if opts[:min] && opts[:max] 
-        ArduinoPlugin.add_servo_struct
-        @servo_pins << num
-        refresh = opts[:refresh] ? opts[:refresh] : 200
-        @servo_settings <<  "serv[#{num}].pin = #{num}, serv[#{num}].pulseWidth = 0, serv[#{num}].lastPulse = 0, serv[#{num}].startPulse = 0, serv[#{num}].refreshTime = #{refresh}, serv[#{num}].min = #{opts[:min]}, serv[#{num}].max = #{opts[:max]}  "
-        unless opts[:device]
-          puts "#{"*"*80} \n   using :max and :min to instantiate a servo is deprecated\n   use :device => :servo instead\n#{"*"*80}"
+          raise ArgumentError, "today's device choices are: :servo, :pa_lcd, :sf_lcd, :freq_out,:i2c, :i2c_eeprom, :i2c_ds1307, and :i2c_blinkm  got #{opts[:device]}"
         end
-      else    
-          raise ArgumentError, "two are required for each servo: min & max" if opts[:min] || opts[:max] 
-          raise ArgumentError, "refresh is an optional servo parameter, don't forget min & max" if opts[:refresh] 
       end
       
   # add state variables for outputs with :state => :on or :off -- useful for toggling a light with output_toggle -- need to make this more modular
@@ -468,81 +336,8 @@ 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
-  
-  ### tuck the following five methods into private once they are solid 
-  
-  def orig_servo_setup(num, opts)
-    ArduinoPlugin.add_servo_struct
-    @servo_pins << num
-    refresh = opts[:refresh] ? opts[:refresh] : 200
-    min = opts[:min] ? opts[:min] : 700
-    max = opts[:min] ? opts[:max] : 2200
-    @servo_settings <<  "serv[#{num}].pin = #{num}, serv[#{num}].pulseWidth = 0, serv[#{num}].lastPulse = 0, serv[#{num}].startPulse = 0, serv[#{num}].refreshTime = #{refresh}, serv[#{num}].min = #{min}, serv[#{num}].max = #{max}  "
-  end
-  
-  # use the servo library
-  def new_servo_setup(num, opts)
-    if opts[:position]
-      raise ArgumentError, "position must be an integer from 0 to 360, got #{opts[:position].class}" unless opts[:position].is_a?(Fixnum)
-      raise ArgumentError, "position must be an integer from 0 to 360---, got #{opts[:position]}" if opts[:position] < 0 || opts[:position] > 360
-    end
-    servo(num, opts)
-    # move this to better place ... 
-    # should probably go along with servo code into plugin
-    @@servo_dh ||= FALSE
-    if (@@servo_dh == FALSE)	# on second instance this stuff can't be repeated - BBR
-      @@servo_dh = TRUE
-      @declarations << "void servo_refresh(void);"
-      helper_methods = []
-      helper_methods << "void servo_refresh(void)"
-      helper_methods << "{"
-      helper_methods <<  "\tServo::refresh();"
-      helper_methods << "}"
-      @helper_methods += "\n#{helper_methods.join("\n")}"
-    end
-  end
-  
-  ## this won't work at all... no pins
-  # need help
-  def lcd_setup(num, opts)
-    # move to plugin and load plugin
-    # what's the default rate?
-    opts[:rate] ||= 9600
-    rate = opts[:rate] ? opts[:rate] : 9600
-    swser_LCD(num, opts)
-  end
-  
-  # use the pa lcd library
-  def pa_lcd_setup(num, opts)
-    if opts[:geometry]
-      raise ArgumentError, "can only define pin from Fixnum, got #{opts[:geometry]}" unless opts[:geometry].is_a?(Fixnum)
-      raise ArgumentError, "pa_lcd geometry must be 216, 220, 224, 240, 416, 420, got #{opts[:geometry]}" unless opts[:geometry].to_s =~ /(216|220|224|240|416|420)/
-    end
-    # move to plugin and load plugin
-    # what's the default?
-     opts[:rate] ||= 9600
-    rate = opts[:rate] ? opts[:rate] : 9600
-    swser_LCDpa(num, opts)
-  end
-  
-  # use the sf (sparkfun) library
-  def sf_lcd_setup(num, opts)
-    if opts[:geometry]
-      raise ArgumentError, "can only define pin from Fixnum, got #{opts[:geometry]}" unless opts[:geometry].is_a?(Fixnum)
-      raise ArgumentError, "sf_lcd geometry must be 216, 220, 416, 420, got #{opts[:geometry]}" unless opts[:geometry].to_s =~ /(216|220|416|420)/
-    end
-    # move to plugin and load plugin
-     opts[:rate] ||= 9600
-    rate = opts[:rate] ? opts[:rate] : 9600
-    swser_LCDsf(num, opts)
-  end
   
-  # Confiugre a single pin for input and setup a method to refer to that pin, i.e.:
+  # Configure a single pin for input and setup a method to refer to that pin, i.e.:
   #
   #   input_pin 3, :as => :button
   #
@@ -614,581 +409,28 @@ class ArduinoSketch
   def serial_begin(opts={})
     rate = opts[:rate] ? opts[:rate] : 9600
     @other_setup << "Serial.begin(#{rate});"
+    @@hwserial_inc = TRUE
   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});"
- 			accessor = []
- 			accessor << "SoftwareSerial& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
- 			@@swser_inc ||= FALSE
- 			if (@@swser_inc == FALSE) # on second instance this stuff can't be repeated
- 				@@swser_inc = TRUE
-	 			accessor << "int read(SoftwareSerial& s) {"
- 				accessor << "\treturn s.read();"
- 				accessor << "}"
- 				accessor << "void println( SoftwareSerial& s, char* str ) {"
- 				accessor << "\treturn s.println( str );"
- 				accessor << "}"
- 				accessor << "void print( SoftwareSerial& s, char* str ) {"
- 				accessor << "\treturn s.print( str );"
- 				accessor << "}"
- 				accessor << "void println( SoftwareSerial& s, int i ) {"
- 				accessor << "\treturn s.println( i );"
- 				accessor << "}"
- 				accessor << "void print( SoftwareSerial& s, int i ) {"
- 				accessor << "\treturn s.print( i );"
- 				accessor << "}"
- 			end
- 			@accessors << accessor.join( "\n" )
- 			
- 			@signatures << "SoftwareSerial& #{opts[ :as ]}();"
- 
- 			@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
-    geometry = opts[:geometry] ? opts[:geometry] : 0
- 		if opts[:as] 
- 			@declarations << "SWSerLCDpa _#{opts[ :as ]} = SWSerLCDpa(#{tx}, #{geometry});"
- 			accessor = []
- 			$load_libraries << "SWSerLCDpa"
- 			accessor << "SWSerLCDpa& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
- 			@@slcdpa_inc ||= FALSE
- 			if (@@slcdpa_inc == FALSE)	# on second instance this stuff can't be repeated - BBR
- 				@@slcdpa_inc = TRUE
- 	 			  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 clearline(SWSerLCDpa& s, int line) {"
- 	 			  accessor << "\treturn s.clearline( line );"
-  				accessor << "}"
-  				accessor << "void setxy( SWSerLCDpa& s, int x, int y) {"
-  				accessor << "\treturn s.setxy( x, y );"
-  				accessor << "}"
-  				accessor << "void clearscr(SWSerLCDpa& s, const char *str) {"
- 	 			  accessor << "\treturn s.clearscr(str);"
-  				accessor << "}"
-   				accessor << "void clearline(SWSerLCDpa& s, int line, const char *str) {"
- 	 			  accessor << "\treturn s.clearline( line, str );"
-  				accessor << "}"
-  				accessor << "void setxy( SWSerLCDpa& s, int x, int y, const char *str) {"
-  				accessor << "\treturn s.setxy( x, y, str );"
-    			accessor << "}"
-  				accessor << "void clearscr(SWSerLCDpa& s, int n) {"
- 	 			  accessor << "\treturn s.clearscr(n);"
-  				accessor << "}"
-   				accessor << "void clearline(SWSerLCDpa& s, int line, int n) {"
- 	 			  accessor << "\treturn s.clearline( line, n );"
-  				accessor << "}"
-  				accessor << "void setxy( SWSerLCDpa& s, int x, int y, int n) {"
-  				accessor << "\treturn s.setxy( x, y, n );"
-    			accessor << "}"
-  				accessor << "void setgeo( SWSerLCDpa& s, int g) {"
-  				accessor << "\treturn s.setgeo( g );"
-  				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 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 << "}"
- 			end
- 			@accessors << accessor.join( "\n" )
- 			
- 			@signatures << "SWSerLCDpa& #{opts[ :as ]}();"
- 
- 			@other_setup << "\t_#{opts[ :as ]}.begin(#{rate});"
- 		end
- 	end 	
-
 
+  def formatted_print(opts={})
 
- 	def swser_LCDsf(tx, opts={})
-    raise ArgumentError, "can only define tx from Fixnum, got #{tx.class}" unless tx.is_a?(Fixnum)
-    output_pin(tx)
+    buffer_size = opts[:buffer_size] ? opts[:buffer_size] : 64
     
-
-    rate = opts[:rate] ? opts[:rate] : 9600
-    geometry = opts[:geometry] ? opts[:geometry] : 0
- 		if opts[:as] 
- 			@declarations << "SWSerLCDsf _#{opts[ :as ]} = SWSerLCDsf(#{tx}, #{geometry});"
- 			accessor = []
- 			$load_libraries << "SWSerLCDsf"
- 			accessor << "SWSerLCDsf& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
- 			@@slcdsf_inc ||= FALSE # assign only if nil
- 			if (@@slcdsf_inc == FALSE)	# on second instance this stuff can't be repeated - BBR
- 				@@slcdsf_inc = TRUE
- 	 			accessor << "void print( SWSerLCDsf& s, uint8_t b ) {"
-	  			accessor << "\treturn s.print( b );"
- 	 			  accessor << "}"
- 	 			  accessor << "void print( SWSerLCDsf& s, const char *str ) {"
-  				accessor << "\treturn s.print( str );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, char c ) {"
-  				accessor << "\treturn s.print( c );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, int i ) {"
-  				accessor << "\treturn s.print( i );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, unsigned int i ) {"
-  				accessor << "\treturn s.print( i );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, long i ) {"
-  				accessor << "\treturn s.print( i );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, unsigned long i ) {"
-  				accessor << "\treturn s.print( i );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, long i, int b ) {"
-  				accessor << "\treturn s.print( i, b );"
-  				accessor << "}"
-  				accessor << "void print( SWSerLCDsf& s, char* str ) {"
-  				accessor << "\treturn s.print( str );"
-  				accessor << "}"
-   				accessor << "void clearscr(SWSerLCDsf& s) {"
- 	 			  accessor << "\treturn s.clearscr();"
-  				accessor << "}"
-  				accessor << "void setxy( SWSerLCDsf& s, int x, int y) {"
-  				accessor << "\treturn s.setxy( x, y );"
-  				accessor << "}"
-  				accessor << "void clearscr(SWSerLCDsf& s, const char *str) {"
- 	 			  accessor << "\treturn s.clearscr(str);"
-  				accessor << "}"
-  				accessor << "void clearscr(SWSerLCDsf& s, int n) {"
- 	 			  accessor << "\treturn s.clearscr(n);"
-  				accessor << "}"
-  				accessor << "void setxy( SWSerLCDsf& s, int x, int y, const char *str) {"
-  				accessor << "\treturn s.setxy( x, y, str );"
-  				accessor << "}"
-  				accessor << "void setxy( SWSerLCDsf& s, int x, int y, int n) {"
-  				accessor << "\treturn s.setxy( x, y, n );"
-  				accessor << "}"
-  				accessor << "void setgeo( SWSerLCDsf& s, int g) {"
-  				accessor << "\treturn s.setgeo( g );"
-  				accessor << "}"
-  				accessor << "void setintensity( SWSerLCDsf& s, int i ) {"
-  				accessor << "\treturn s.setintensity( i );"
-  				accessor << "}"
-  				accessor << "void setcmd( SWSerLCDsf& s, uint8_t a, uint8_t b) {"
-  				accessor << "\treturn s.setcmd( a, b );"
-  				accessor << "}"
-  			end
- 			@accessors << accessor.join( "\n" )
- 			
- 			@signatures << "SWSerLCDsf& #{opts[ :as ]}();"
- 
- 			@other_setup << "\t_#{opts[ :as ]}.begin(#{rate});"
- 		end
- 	end 	
-
-
-  def twowire_stepper(pin1, pin2, opts={}) # servo motor routines #
-    raise ArgumentError, "can only define pin1 from Fixnum, got #{pin1.class}" unless pin1.is_a?(Fixnum)
-    raise ArgumentError, "can only define pin2 from Fixnum, got #{pin2.class}" unless pin2.is_a?(Fixnum)
-        
-    st_speed = opts[:speed] ? opts[:speed] : 30
-    st_steps = opts[:steps] ? opts[:steps] : 100
-    
-   		if opts[:as]
- 			@declarations << "Stepper _#{opts[ :as ]} = Stepper(#{st_steps},#{pin1},#{pin2});"
- 			accessor = []
- 			$load_libraries << "Stepper"
- 			accessor << "Stepper& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
-      @@stepr_inc ||= FALSE
- 			if (@@stepr_inc == FALSE)	# on second instance this stuff can't be repeated - BBR
- 				@@stepr_inc = TRUE
- 				accessor << "void set_speed( Stepper& s, long sp ) {"
- 				accessor << "\treturn s.set_speed( sp );"
- 				accessor << "}"
- 				accessor << "void set_steps( Stepper& s, int b ) {"
-	 			accessor << "\treturn s.set_steps( b );"
- 				accessor << "}"
- 				accessor << "int version( Stepper& s ) {"
- 				accessor << "\treturn s.version();"
- 				accessor << "}"
-			end
- 			
- 			@accessors << accessor.join( "\n" )
- 			
- 			@signatures << "Stepper& #{opts[ :as ]}();"
-
- 			@other_setup << "\t_#{opts[ :as ]}.set_speed(#{st_speed});" if opts[:speed]
-
- 		end
- 	end 
- 	
-
-  def fourwire_stepper( pin1, pin2, pin3, pin4, opts={}) # servo motor routines #
-    raise ArgumentError, "can only define pin1 from Fixnum, got #{pin1.class}" unless pin1.is_a?(Fixnum)
-    raise ArgumentError, "can only define pin2 from Fixnum, got #{pin2.class}" unless pin2.is_a?(Fixnum)
-    raise ArgumentError, "can only define pin3 from Fixnum, got #{pin3.class}" unless pin3.is_a?(Fixnum)
-    raise ArgumentError, "can only define pin4 from Fixnum, got #{pin4.class}" unless pin4.is_a?(Fixnum)
-        
-    st_speed = opts[:speed] ? opts[:speed] : 30
-    st_steps = opts[:steps] ? opts[:steps] : 100
-    
-   		if opts[:as]
- 			@declarations << "Stepper _#{opts[ :as ]} = Stepper(#{st_steps},#{pin1},#{pin2},#{pin3},#{pin4});"
- 			accessor = []
- 			$load_libraries << "Stepper"
- 			accessor << "Stepper& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
-      @@stepr_inc ||= FALSE
- 			if (@@stepr_inc == FALSE)	# on second instance this stuff can't be repeated - BBR
- 				@@stepr_inc = TRUE
- 				accessor << "void set_speed( Stepper& s, long sp ) {"
- 				accessor << "\treturn s.set_speed( sp );"
- 				accessor << "}"
- 				accessor << "void set_steps( Stepper& s, int b ) {"
-	 			accessor << "\treturn s.set_steps( b );"
- 				accessor << "}"
- 				accessor << "int version( Stepper& s ) {"
- 				accessor << "\treturn s.version();"
- 				accessor << "}"
-			end
- 			
- 			@accessors << accessor.join( "\n" )
- 			
- 			@signatures << "Stepper& #{opts[ :as ]}();"
-
- 			@other_setup << "\t_#{opts[ :as ]}.set_speed(#{st_speed});" if opts[:speed]
-
- 		end
- 	end 
-
-
-  def servo(pin, opts={}) # servo motor routines #
-    raise ArgumentError, "can only define pin from Fixnum, got #{pin.class}" unless pin.is_a?(Fixnum)
-        
-    minp = opts[:min] ? opts[:min] : 544
-    maxp = opts[:max] ? opts[:max] : 2400
-
-   		if opts[:as]
- 			@declarations << "Servo _#{opts[ :as ]} = Servo();"
- 			accessor = []
- 			$load_libraries << "Servo"
- 			accessor << "Servo& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
-      @@servo_inc ||= FALSE
- 			if (@@servo_inc == FALSE)	# on second instance this stuff can't be repeated - BBR
- 				@@servo_inc = TRUE
- 				accessor << "void detach( Servo& s ) {"
- 				accessor << "\treturn s.detach();"
- 				accessor << "}"
- 				accessor << "void position( Servo& s, int b ) {"
-	 			accessor << "\treturn s.position( b );"
- 				accessor << "}"
- 				accessor << "void speed( Servo& s, int b ) {"
- 				accessor << "\treturn s.speed( b );"
- 				accessor << "}"
- 				accessor << "uint8_t read( Servo& s ) {"
- 				accessor << "\treturn s.read();"
- 				accessor << "}"
- 				accessor << "uint8_t attached( Servo& s ) {"
- 				accessor << "\treturn s.attached();"
- 				accessor << "}"
- 				accessor << "static void refresh( Servo& s ) {"
- 				accessor << "\treturn s.refresh();"
- 				accessor << "}"
- 			end
- 			
- 			@accessors << accessor.join( "\n" )
- 			
- 			@signatures << "Servo& #{opts[ :as ]}();"
-
- 			@other_setup << "\t_#{opts[ :as ]}.attach(#{pin}, #{opts[:position]}, #{minp}, #{maxp});" if opts[:position]
- 			@other_setup << "\t_#{opts[ :as ]}.attach(#{pin}, #{minp}, #{maxp});" unless opts[:position]
-
- 		end
- 	end 
- 	
- 	def frequency_timer(pin, opts={}) # frequency timer routines
-
-    raise ArgumentError, "can only define pin from Fixnum, got #{pin.class}" unless pin.is_a?(Fixnum)
-    raise ArgumentError, "only pin 11 may be used for freq_out, got #{pin}" unless pin == 11
-    
-    if opts[:enable]
-      raise ArgumentError, "enable option must include the frequency or period option" unless opts[:frequency] || opts[:period]
-    end
-    if opts[:frequency]
-      raise ArgumentError, "the frequency option must be an integer, got #{opts[:frequency].class}" unless opts[:frequency].is_a?(Fixnum)
-    end
-    if opts[:period]
-      raise ArgumentError, "the frequency option must be an integer, got #{opts[:period].class}" unless opts[:period].is_a?(Fixnum) 
-    end
-    # refer to: http://www.arduino.cc/playground/Code/FrequencyTimer2
-
-   		if opts[:as]
-   		  
-   		  @@frequency_inc = TRUE
-   		  @declarations << "FrequencyTimer2 _#{opts[ :as ]} = FrequencyTimer2();"
-   			accessor = []
-   			$load_libraries << "FrequencyTimer2"	
-   			accessor << "FrequencyTimer2& #{opts[ :as ]}() {"
-   			accessor << "\treturn _#{opts[ :as ]};"
-   			accessor << "}"
-   			# add ||=
-#   		if (@@frequency_inc == FALSE)	# on second instance this stuff can't be repeated - BBR
-   			# @@frequency_inc = TRUE
-   			accessor << "void set_frequency( FrequencyTimer2& s, int b ) {"
-   			accessor << "\treturn s.setPeriod( 1000000L/b );"
-   			accessor << "}"
-   			accessor << "void set_period( FrequencyTimer2& s, int b ) {"
-  	 		accessor << "\treturn s.setPeriod( b );"
-   			accessor << "}"
-   			accessor << "void enable( FrequencyTimer2& s ) {"
-   			accessor << "\treturn s.enable();"
-   			accessor << "}"
-   			accessor << "void disable( FrequencyTimer2& s ) {"
-   			accessor << "\treturn s.disable();"
-   			accessor << "}"
-#   		end
-
-   			@accessors << accessor.join( "\n" )
-
-   			@signatures << "FrequencyTimer2& #{opts[ :as ]}();"
-	
-		    @other_setup << "\tFrequencyTimer2::setPeriod(0L);" unless opts[:frequency] || opts[:period]
- 			  @other_setup << "\tFrequencyTimer2::setPeriod(1000000L/#{opts[:frequency]});" if opts[:frequency]
- 			  @other_setup << "\tFrequencyTimer2::setPeriod(#{opts[:period]});" if opts[:period]
- 			  @other_setup << "\tFrequencyTimer2::enable();" if opts[:enable] == :true
- 		end
- 	end	
-
-  def one_wire(pin, opts={})
-    raise ArgumentError, "can only define pin from Fixnum, got #{pin.class}" unless pin.is_a?(Fixnum)
-
     if opts[:as]
-      @declarations << "OneWire _#{opts[ :as ]} = OneWire(#{pin});"
-      accessor = []
-      $load_libraries << "OneWire"
-      accessor << "OneWire& #{opts[ :as ]}() {"
-      accessor << "\treturn _#{opts[ :as ]};"
-      accessor << "}"
-      @@onewire_inc ||= FALSE
-      if (@@onewire_inc == FALSE)     # on second instance this stuff can't be repeated - BBR
-        @@onewire_inc = TRUE
-        accessor << "uint8_t reset(OneWire& s) {"
-        accessor << "\treturn s.reset();"
-        accessor << "}"
-        accessor << "void skip(OneWire& s) {"
-        accessor << "\treturn s.skip();"
-        accessor << "}"
-        accessor << "void write(OneWire& s, uint8_t v, uint8_t p = 0) {" # "power = 0"  ?????
-        accessor << "\treturn s.write( v, p );"
-        accessor << "}"
-        accessor << "uint8_t read(OneWire& s) {"
-        accessor << "\treturn s.read();"
-        accessor << "}"
-        accessor << "void write_bit( OneWire& s, uint8_t b ) {"
-        accessor << "\treturn s.write_bit( b );"
-        accessor << "}"
-        accessor << "uint8_t read_bit(OneWire& s) {"
-        accessor << "\treturn s.read_bit();"
-        accessor << "}"
-        accessor << "void depower(OneWire& s) {"
-        accessor << "\treturn s.depower();"
-        accessor << "}"
+      @@sprintf_inc ||= FALSE
+      if @@sprintf_inc == FALSE
+        @@sprintf_inc = TRUE
+        accessor = []
+        accessor << "\n#undef int\n#include <stdio.h>"
+        accessor << "#define write_line(...) sprintf(#{opts[:as]},__VA_ARGS__);"
+        @accessors << accessor.join( "\n" )
+        array("char #{opts[:as]}[#{buffer_size}]") 
       end
-      @accessors << accessor.join( "\n" )
-
-      @signatures << "OneWire& #{opts[ :as ]}();"
     end
   end
 
- 	def two_wire (pin, opts={}) # i2c Two-Wire
-
-    	raise ArgumentError, "can only define pin from Fixnum, got #{pin.class}" unless pin.is_a?(Fixnum)
-    	raise ArgumentError, "only pin 19 may be used for i2c, got #{pin}" unless pin == 19
-
-   		if opts[:as]
-
-   			@@twowire_inc = TRUE
-   		    @declarations << "TwoWire _wire = TwoWire();"
-#   		    @declarations << "TwoWire _#{opts[ :as ]} = TwoWire();"
-   			accessor = []
-   			$load_libraries << "Wire"	
-   			accessor << "TwoWire& wire() {"
-   			accessor << "\treturn _wire;"
-#   			accessor << "TwoWire& #{opts[ :as ]}() {"
-#   			accessor << "\treturn _#{opts[ :as ]};"
-   			accessor << "}"
-   			accessor << "void begin( TwoWire& s) {"
-   			accessor << "\treturn s.begin();"
-   			accessor << "}"
-   			accessor << "void begin( TwoWire& s, uint8_t a) {"
-   			accessor << "\treturn s.begin(a);"
-   			accessor << "}"
-   			accessor << "void begin( TwoWire& s, int a) {"
-   			accessor << "\treturn s.begin(a);"
-   			accessor << "}"
-   			accessor << "void beginTransmission( TwoWire& s, uint8_t a ) {"
-   			accessor << "\treturn s.beginTransmission( a );"
-   			accessor << "}"
-   			accessor << "void beginTransmission( TwoWire& s, int a ) {"
-   			accessor << "\treturn s.beginTransmission( a );"
-   			accessor << "}"
-   			accessor << "void endTransmission( TwoWire& s ) {"
-   			accessor << "\treturn s.endTransmission();"
-   			accessor << "}"
-   			accessor << "void requestFrom( TwoWire& s, uint8_t a, uint8_t q) {"
-   			accessor << "\treturn s.requestFrom( a, q );"
-   			accessor << "}"
-   			accessor << "void requestFrom( TwoWire& s, int a, int q) {"
-   			accessor << "\treturn s.requestFrom( a, q );"
-   			accessor << "}"
-   			accessor << "void send( TwoWire& s, uint8_t d) {"
-   			accessor << "\treturn s.send(d);"
-   			accessor << "}"
-   			accessor << "void send( TwoWire& s, int d) {"
-   			accessor << "\treturn s.send(d);"
-   			accessor << "}"
-   			accessor << "void send( TwoWire& s, char* d) {"
-   			accessor << "\treturn s.send(d);"
-   			accessor << "}"
-   			accessor << "void send( TwoWire& s, uint8_t* d, uint8_t q) {"
-   			accessor << "\treturn s.send( d, q );"
-   			accessor << "}"
-   			accessor << "uint8_t available( TwoWire& s) {"
-   			accessor << "\treturn s.available();"
-   			accessor << "}"
-   			accessor << "uint8_t receive( TwoWire& s) {"
-   			accessor << "\treturn s.receive();"
-   			accessor << "}"
-
-   			@accessors << accessor.join( "\n" )
-
-   			@signatures << "TwoWire& wire();"
-#   			@signatures << "TwoWire& #{opts[ :as ]}();"
-
- 			@other_setup << "\t_wire.begin();" if opts[:enable] == :true
-# 			@other_setup << "\t_#{opts[ :as ]}.begin();" if opts[:enable] == :true
-
- 		end
- 	end	
-
-	def ds1307(pin, opts={}) # DS1307 motor routines
-    	raise ArgumentError, "can only define pin from Fixnum, got #{pin.class}" unless pin.is_a?(Fixnum)
-        raise ArgumentError, "only pin 19 may be used for i2c, got #{pin}" unless pin == 19
-#		raise ArgumentError, "only one DS1307  may be used for i2c" if @@ds1307_inc == :true
-
-   		if opts[:as]
- 			@@ds1307_inc = TRUE
- 			@declarations << "DS1307 _#{opts[ :as ]} = DS1307();"
- 			accessor = []
- 			$load_libraries << "DS1307"
- 			accessor << "DS1307& #{opts[ :as ]}() {"
- 			accessor << "\treturn _#{opts[ :as ]};"
- 			accessor << "}"
- 			accessor << "int get( DS1307& s, int b, boolean r ) {"
- 			accessor << "\treturn s.get( b, r );"
- 			accessor << "}"
- 			accessor << "void set( DS1307& s, int b, int r ) {"
- 			accessor << "\treturn s.set( b, r );"
- 			accessor << "}"
- 			accessor << "void start( DS1307& s ) {"
- 			accessor << "\treturn s.start();"
- 			accessor << "}"
- 			accessor << "void stop( DS1307& s ) {"
- 			accessor << "\treturn s.stop();"
- 			accessor << "}"
-
- 			@accessors << accessor.join( "\n" )
-
- 			@signatures << "DS1307& #{opts[ :as ]}();"
- 			@other_setup << "\t_#{opts[ :as ]}.start();" if opts[:rtcstart]
-
- 		end
- 	end 
-
-
-
-	def blinkm
-
-	end
-
-
+  
 
 
   def compose_setup #:nodoc: also composes headers and signatures
@@ -1302,8 +544,10 @@ class ArduinoSketch
     # need to add plugin name to this... 
     $plugin_methods.each { |meth| helpers << "#{meth[0][0]}\n" } unless $plugin_methods.nil? || $plugin_methods.empty?
     
-    helpers << "\n// serial helpers"
-    helpers << serial_boilerplate.lstrip
+    if @@hwserial_inc == TRUE
+      helpers << "\n// serial helpers"
+      helpers << serial_boilerplate.lstrip
+    end
     
     main << "\n" + comment_box( "main() function" )
     main << "int main() {"
@@ -1320,9 +564,6 @@ class ArduinoSketch
   end
   
   
- 
-  
-  
   # 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
@@ -1366,68 +607,14 @@ class ArduinoSketch
       if e !~ /^\s*(#{C_VAR_TYPES})(\W{1,6}|\(unsigned\()(#{$external_var_identifiers.join("|")})/ || $external_var_identifiers.empty?
         # use the list of identifers the external_vars method of the sketch and remove the parens the ruby2c sometime adds to variables
         # keep an eye on the gsub!.. are we getting nil errors
-        e.gsub!(/((#{$external_var_identifiers.join("|")})\(\))/, '\2')  unless $external_var_identifiers.empty? 
+        # and more recently, the \b
+        e.gsub!(/\b((#{$external_var_identifiers.join("|")})\(\))/, '\2')  unless $external_var_identifiers.empty?
         clean_c_methods << e
       end
       return clean_c_methods.join( "\n" )
   end
   
-  private
-  
-  def serial_boilerplate #:nodoc:
-    out = []
-    out << "int serial_available() {"
-    out << "\treturn (Serial.available() > 0);"
-    out << "}"
-
-    out << "char serial_read() {"
-    out << "\treturn (char) Serial.read();"
-    out << "}"
-
-    out << "void serial_flush() {"
-    out << "\treturn Serial.flush();"
-    out << "}"
-
-    out << "void serial_print( char str ) {"
-    out << "\treturn Serial.print( str );"
-    out << "}"
-    
-    out << "void serial_print( char* str ) {"
-    out << "\treturn Serial.print( str );"
-    out << "}"
-    
-    out << "void serial_print( int i ) {"
-    out << "\treturn Serial.print( i );"
-    out << "}"
-    
-    out << "void serial_print( long i ) {"
-    out << "\treturn Serial.print( i );"
-    out << "}"
-  
- 		out << "void serial_println( char* str ) {"
-    out << "\treturn Serial.println( str );"
-    out << "}"
-    
-    out << "void serial_println( char str ) {"
-    out << "\treturn Serial.println( str );"
-    out << "}"
- 
-  	out << "void serial_println( int i ) {"
-    out << "\treturn Serial.println( i );"
-    out << "}"
-    
-    out << "void serial_println( long i ) {"
-    out << "\treturn Serial.println( i );"
-    out << "}"
-    
-    ## added to support millis
-    out << "void serial_print( unsigned long i ) {"
-    out << "\treturn Serial.print( i );"
-    out << "}"
 
-    return out.join( "\n" )
-  end
-  
   def comment_box( content ) #:nodoc:
     out = []
     out << "/" * 74
@@ -1438,4 +625,4 @@ class ArduinoSketch
   end  
 
   
-end
+end