rad 0.2.2 → 0.2.9

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

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