madrona-rad 0.2.2

data/lib/plugins/input_output_state.rb

@@ -0,0 +1,84 @@
+class InputOutputState < 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 ARY_SIZE 10"
+  
+# add to external variables
+#external_variables "int *cur, *scan, *start, *end;", "int sm_ary[ARY_SIZE];"
+
+# add the following to the setup method
+#add_to_setup "scan = &sm_ary[0];", "cur = &sm_ary[0];", "start = &sm_ary[0];", "end = &sm_ary[ARY_SIZE-1];"
+
+# return states of button and servo output stored in 
+# array structs dbcd (debounce) and serv (servo)
+# need error catch ...
+# how about auto generating documentation from plugins
+# at least showing 
+
+
+
+int find_debounce_state(int input)
+{
+return dbce[input].state;
+}
+
+int find_debounce_read(int input)
+{
+return dbce[input].read;
+}
+
+int find_debounce_prev(int input)
+{
+return dbce[input].prev;
+}
+
+unsigned long find_debounce_time(int input)
+{
+return dbce[input].time;
+}
+
+int find_debounce_adjust(int input)
+{
+return dbce[input].adjust;
+}
+
+long unsigned find_servo_pulse_width(int input)
+{
+return serv[input].pulseWidth;
+}
+
+unsigned long find_servo_last_pulse(int input)
+{
+return serv[input].lastPulse;
+}
+
+unsigned long find_servo_start_pulse(int input)
+{
+return serv[input].startPulse;
+
+}
+
+unsigned long find_servo_refresh_time(int input)
+{
+return serv[input].refreshTime;
+}
+
+int find_servo_min(int input)
+{
+return serv[input].min;
+}
+
+int find_servo_max(int input)
+{
+return serv[input].max;
+
+}
+
+
+end

data/lib/plugins/mem_test.rb

@@ -0,0 +1,37 @@
+class MemTest < 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 generated automatically with rake make:upload
+  
+  # test the memory on your arduino uncommenting the following:
+  # add_to_setup "memoryTest();"
+  # or adding "memoryTest()" (no semicolon) to your main sketch
+
+int memoryTest() {
+  int byteCounter = 0; // initialize a counter
+  byte *byteArray; // create a pointer to a byte array
+  while ( (byteArray = (byte*) malloc (byteCounter * sizeof(byte))) != NULL ) {
+   byteCounter++; // if allocation was successful, then up the count for the next try
+    free(byteArray); // free memory after allocating it
+ }
+
+ free(byteArray); // also free memory after the function finishes"
+ return byteCounter; // send back the highest number of bytes successfully allocated
+}
+
+
+end

data/lib/plugins/servo_pulse.rb

@@ -0,0 +1,31 @@
+class ServoPulse < 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 generated automatically with rake make:upload
+  
+# call pulse(us) to pulse a servo  
+# this can be eliminate since we have an identical pulse_servo in servo_setup
+
+void pulse(int pin, int us) {
+  digitalWrite( pin, HIGH );
+  delayMicroseconds( us );
+  digitalWrite( pin, LOW );
+  serv[pin].pulseWidth = us;
+}
+    
+
+end

data/lib/plugins/servo_setup.rb

@@ -0,0 +1,86 @@
+class ServoSetup < 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 generated automatically with rake make:upload
+  
+  
+  # one line servo control 
+  #
+  # move_servo my_servo, amount
+  #
+  # example:
+  # 
+  #   class MoveServo < ArduinoSketch
+  #
+  #     external_vars :sensor_position => "int, 0", :servo_amount => "int, 0"
+  #
+  #     output_pin 4, :as => :my_servo, :min => 700, :max => 2200
+  #     input_pin 1, :as => :sensor
+  #     def loop
+  #       sensor_position = analogRead(sensor)
+  #       servo_amount = (sensor_position*2 + 500)
+  #       move_servo my_servo, servo_amount
+  #     end
+  #   end
+  #
+  #
+  #  supports multiple servos by storing variables in the serv struc array that is constructed when
+  #  the :min and :max options are added to the output_pin method
+  
+
+add_servo_struct
+
+void move_servo(int servo_num, int pulse_width)
+{
+  struct servo servo_name = serv[servo_num];
+
+  int pw = pulse_width;
+  /* apply the servo limits */
+  if (pw > servo_name.max)
+    pw = servo_name.max;
+  if (pw < servo_name.min)
+    pw = servo_name.min;
+
+  if (millis() - servo_name.lastPulse >= servo_name.refreshTime)
+    {
+      pulse_servo(servo_name.pin, pw);
+      servo_name.lastPulse = millis();
+      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
+      delay(18);
+    }
+
+}
+
+void pulse_servo(int pin, int us) {
+  digitalWrite( pin, HIGH );
+  // pulseWidth
+  delayMicroseconds( us );
+  digitalWrite( pin, LOW );
+  serv[pin].pulseWidth = us;
+}
+
+
+
+
+
+
+    
+
+end

data/lib/plugins/smoother.rb

@@ -0,0 +1,54 @@
+class Smoother < 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 ARY_SIZE 10"
+
+  # add to external variables
+  external_variables "int *cur, *scan, *start, *end;", "int sm_ary[ARY_SIZE];", "int last_reading = 0;"
+
+  # add the following to the setup method
+  add_to_setup "scan = &sm_ary[0];", "cur = &sm_ary[0];", "start = &sm_ary[0];", "end = &sm_ary[ARY_SIZE-1];"
+
+  # add an element to the array and return the average
+
+int add_hysteresis(int reading, int hysteresis)
+{
+  if ( ((reading - last_reading) > hysteresis) || ((last_reading - reading) > hysteresis)) {
+
+          last_reading = reading;
+          return reading;
+       }
+     else
+       return last_reading;
+}
+
+int smooth_average(int reading)
+{
+  int sum, cnt;
+  cnt = 0;
+  sum = 0;
+  *cur = reading;
+  cur++;
+  for (scan = &sm_ary[0]; scan < &sm_ary[ARY_SIZE-1]; cnt++, scan++)
+    sum += *scan;
+  ptr_reset();
+  return sum/cnt;
+}
+
+void ptr_reset(void)
+{
+  if (cur == end)
+  {
+    cur = &sm_ary[0];
+  }
+}
+
+
+
+end

data/lib/plugins/spark_fun_serial_lcd.rb

@@ -0,0 +1,100 @@
+class SparkFunSerialLcd < 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)
+  # hack from http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1209050315
+
+  plugin_directives "#undef int", "#include <stdio.h>", "char _str[32];", "#define writeln(...) sprintf(_str, __VA_ARGS__); Serial.println(_str)"
+  # add to directives
+  #plugin_directives "#define EXAMPLE 10"
+
+  # add to external variables
+  external_variables "char status_message[40] = \"very cool\"", "char* msg[40]"
+
+  # 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 generated automatically with rake make:upload
+  
+# methods for sparkfun serial lcd SerLCD v2.5
+
+void print_sensor_position_plus(int reading){
+
+
+/*  writeln("sensor: %d ", reading); */
+  Serial.print("sensor: ");
+  Serial.print(reading);
+
+  
+}
+
+void print_sensor_position(long pos){
+  Serial.print(pos);
+}
+
+void lcd_first_line(){  //puts the cursor at line 0 char 0.
+   Serial.print(0xFE, BYTE);   //command flag
+   Serial.print(128, BYTE);    //position
+}
+
+void lcd_second_line(){  //puts the cursor at line 0 char 0.
+   Serial.print(0xFE, BYTE);   //command flag
+   Serial.print(192, BYTE);    //position
+}
+
+void selectLineOne(){  //puts the cursor at line 0 char 0.
+   Serial.print(0xFE, BYTE);   //command flag
+   Serial.print(128, BYTE);    //position
+}
+void selectLineTwo(){  //puts the cursor at line 0 char 0.
+   Serial.print(0xFE, BYTE);   //command flag
+   Serial.print(192, BYTE);    //position
+}
+void clearLCD(){
+   Serial.print(0xFE, BYTE);   //command flag
+   Serial.print(0x01, BYTE);   //clear command.
+}
+void backlightOn(){  //turns on the backlight
+    Serial.print(0x7C, BYTE);   //command flag for backlight stuff
+    Serial.print(157, BYTE);    //light level.
+}
+
+void set_backlight_level(int level){  //turns on the backlight
+  if (level > 29)
+    level = 29;
+    Serial.print(0x7C, BYTE);   //command flag for backlight stuff
+    Serial.print(157 + level, BYTE);    //light level.
+}
+
+void toggle_backlight(){  //turns off the backlight
+    Serial.print(0x7C, BYTE);   //command flag for backlight stuff
+    Serial.print("|");     //light level for off.
+    Serial.print(1);
+}
+
+void set_splash(){
+  selectLineOne();
+  Serial.print(" Ruby + Auduino");
+  selectLineTwo();
+  Serial.print(" RAD 0.2.2+     ");
+  Serial.print(0x7C, BYTE);   // decimal 124, command flag for backlight stuff
+  Serial.print(10, BYTE);
+}
+
+void backlightOff(){  //turns off the backlight
+    Serial.print(0x7C, BYTE);   // decimal 124, command flag for backlight stuff
+    Serial.print(128, BYTE);     //light level for off.
+}
+void serCommand(){   // decimal 254, a general function to call the command flag for issuing all other commands   
+  Serial.print(0xFE, BYTE);
+}
+
+
+
+
+    
+
+end

data/lib/rad/arduino_plugin.rb

@@ -0,0 +1,202 @@
+## RAD plugins -- the start
+
+## June 25, 2008
+## jd@jdbarnhart.com
+## 
+
+
+# Disclaimer: This is only a first run at the notion of plugins and started off as just a way to keep from adding everything to ArduinoSketch.  
+# ArduinoPlugin is the RAD class for adding "plugins" which add functionality such as servo control, special lcd screen methods, debounce methods, etc.. Sub-classes of ArduinoPlugin (the plugins) add  class methods for doing thing beyond the most common kinds of setup needed when programming the Arduino.  Here is an example of controlling a servo:
+#
+#   class MoveServo < ArduinoSketch
+#
+#     external_vars :sensor_position => "int, 0", :servo_amount => "int, 0"
+#
+#     output_pin 4, :as => :my_servo, :min => 700, :max => 2200
+#     input_pin 1, :as => :sensor
+#     def loop
+#       sensor_position = analogRead(sensor)
+#       servo_amount = (sensor_position*2 + 500)
+#       move_servo my_servo, servo_amount
+#     end
+#   end
+#
+# 
+# Here's one for latching an led
+
+#   output_pin 5, :as => :red_led
+#   input_pin 8, :as => :red_button, :latch => :off, # optional adjustment to amount of time for debounce (default 200) :adjust => 250
+#                                                    # latch sets the led as on or off initially and sets up a array of structs to keep timing and state
+#
+#     def loop
+#       debounce_toggle(red_button, red_led)
+#     end
+#   end
+#
+# Since this is a first pass, there is work to do here, such as 
+#   checking if plugin methods are needed and only loading those that are, 
+#   more compreshensive plugin organization (more railsish with tests, etc)
+#   a scheme to encourage plugin authors and provide an easy way to avoid method and variable namespace collisions
+#   a scheme to flag when a prerequisite plugin is required
+# on with the show:
+
+
+
+class ArduinoPlugin
+  
+def initialize #:nodoc:
+  
+  $plugin_directives = $plugin_directives || []
+  $plugin_external_variables = $plugin_external_variables || []
+  # moved to check_for_plugin_use $plugin_structs = $plugin_structs || {}
+  $plugin_signatures = $plugin_signatures || []
+  $plugin_methods = $plugin_methods || []
+ # $plugin_methods_hash = $plugin_methods_hash || {}  ### new
+ # $plugins_to_load = $plugins_to_load || []  ### new
+  $add_to_setup = $add_to_setup || []
+
+
+end
+  
+# c declarations are automatic
+# you won't need them in the plugins
+# so, the first thing we can do is gather all the plugin methods, and scan the 
+# sketch available plugins...
+# if the sketch has them, we include the plugins in the build...
+# otherwise not..
+
+
+  def add_to_setup(*args)
+    if args
+       args.each do |arg|
+         $add_to_setup << arg
+       end
+     end
+  end
+
+
+  def plugin_directives(*args)
+    if args
+       args.each do |arg|
+         $plugin_directives << arg
+       end
+     end
+  end
+
+
+  def external_variables(*args)
+    if args
+       args.each do |arg|
+         puts self.class
+         puts "\tadding plugin external variables: #{arg}"
+         # colons aptional
+         colon  = arg[arg.length - 1, 1] == ";"  ? '' : ';' 
+         $plugin_external_variables << "#{arg}#{colon}"
+       end
+     end
+  end
+  
+  def add_debounce_struct
+    $plugin_structs[:debounce] = <<-STR
+    struct debounce {
+      int state;
+      int read;
+      int prev;
+      unsigned long time;
+      unsigned long adjust;
+    };
+    STR
+  end
+  
+  
+  def add_servo_struct 
+    $plugin_structs[:servo] = <<-STR
+    struct servo {
+      int pin;
+      long unsigned pulseWidth;
+      long unsigned lastPulse;
+      long unsigned startPulse;
+      long unsigned refreshTime;
+      int min;
+      int max;
+    };
+    STR
+  end
+  
+  def self.add_debounce_struct
+    $plugin_structs[:debounce] = <<-STR
+    struct debounce {
+      int state;
+      int read;
+      int prev;
+      unsigned long time;
+      unsigned long adjust;
+    };
+    STR
+  end
+  
+  
+  def self.add_servo_struct
+    $plugin_structs[:servo] = <<-STR
+    struct servo {
+      int pin;
+      long unsigned pulseWidth;
+      long unsigned lastPulse;
+      long unsigned startPulse;
+      long unsigned refreshTime;
+      int min;
+      int max;
+    };
+    STR
+  end
+  
+
+  def self.check_for_plugin_use(sketch_string, plugin_string, file_name) # rename klass to filename
+    $plugin_structs = $plugin_structs || {}
+    $plugin_methods_hash = $plugin_methods_hash || {}  
+    $plugins_to_load = $plugins_to_load || []  
+    plugin_signatures = []
+    plugin_methods = []
+    ## need a test for this
+    ## fails on string interpolation, but since ruby_to_c also currently fails ...
+    sketch_string = sketch_string.gsub(/#(?!\{.*\}).*/, "")
+    plugin_signatures << plugin_string.scan(/^\s((int|void|unsigned|long|short).*\(.*\))/)
+    # gather just the method name and then add to #plugin_methods_hash
+    plugin_signatures[0].map {|sig| "#{sig[0]}"}.each {|m| plugin_methods << m.gsub!(/^.*\s(\w*)\(.*\)/, '\1')}
+    # we don't know the methods yet, so... 
+    $plugin_methods_hash[file_name] = plugin_methods
+    $plugin_methods_hash.each do |k,meths|
+      meths.each do |meth|
+        if sketch_string.include?(meth)
+           # load this plugin... 
+           $plugins_to_load << k unless $plugins_to_load.include?(k)
+         end
+      end
+    end
+
+  end
+
+
+  def self.process(plugin_string)
+    plugin_signatures = []
+    first_process = plugin_string 
+    # todo: need to add plugin names to the methods, so we can add them as comments in the c code
+    # gather the c methods
+    $plugin_methods << first_process.scan(/^\s*(((int|void|unsigned|long|short).*\)).*(\n.*)*^\s*\})/)
+    plugin_signatures << first_process.scan(/^\s((int|void|unsigned|long|short).*\(.*\))/)
+    $plugin_signatures << plugin_signatures[0].map {|sig| "#{sig[0]};"}
+    ## strip out the methods and pass it back 
+    result = plugin_string
+    # strip out the c methods so we have only ruby before eval
+    result.gsub(/^\s*(int|void|unsigned|long|short).*(\n.*)*^\s*\}/, ""  )
+    
+  end
+  
+  private
+  
+  def add_struct(struct)
+    
+    
+  end
+    
+end