atduskgreg-rad 0.2.5

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_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.4+     ");
+  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/plugins/spectra_symbol.rb

@@ -0,0 +1,79 @@
+class SpectraSymbol < ArduinoPlugin
+  
+# jdbarnhart
+# 20080729
+#
+# crazy experiment in progress
+# purpose
+#
+# retain last reading after finger is removed from spectrasymbol
+# soft pot
+#
+# use
+# two steps
+#
+#  one
+#    declare :device => :sensor 
+#    example:
+#      input_pin 1, :as => :sensor_one, :device => :spectra
+#
+#  two
+#    instead of:
+#      my_lcd.print analogRead sensor_two
+#      use soft_lock
+#      my_lcd.print sensor_one.spectra_lock
+#      
+#
+# notes:
+# experimental settings for 100mm spectrasymbol
+# 
+# hysteresis is set at 5 
+# amount of sensor drop is set to 3
+# delay time (dtime) is 4
+# cutoff set to 10
+#
+int soft_lock(int pin)
+
+{
+  int hyst = 5;
+  int drop = 3;
+  int dtime = 4;
+  int cutoff = 10;
+  int read;
+  int r1;
+  int r2;
+  int r3;
+  unsigned int i;
+  read = analogRead(pin)/4;
+  delay(dtime);
+  r1 = analogRead(pin)/4;
+  delay(dtime);
+  r2 = analogRead(pin)/4;
+  delay(dtime);
+  r3 = analogRead(pin)/4;
+  delay(dtime);
+  for (i = 0; i < (int) (sizeof(spec) / sizeof(spec[0])); i++) {   
+    if (pin == spec[i].pin) {
+      if (((r3 - r2) > drop) && ((r2 - r1) > drop) && ((r1 - read) > drop)) 
+        return spec[i].state - 10;
+      else
+      {
+      if (read < cutoff) 
+        return spec[i].state - 10;
+      else
+      {
+          if (((read - spec[i].state) > hyst ) || ((spec[i].state - read) > hyst )) {
+            spec[i].state = read;
+            return spec[i].state - 10;
+          } 
+          else
+            return spec[i].state - 10;   
+        } 
+      }   
+    } 
+  } 
+}
+
+
+
+end