rad 0.2.2 → 0.2.9

data/lib/plugins/debounce.rb

@@ -0,0 +1,138 @@
+class Debounce < 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
+  # ok, we need to deal with 
+  # what about variables 
+  # need to loose the colon...
+  # 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
+  
+# call pulse(us) to pulse a servo 
+
+#####################
+
+## How this works
+
+##  The cast:
+##   a normally open push button (circuit is closed when button is depressed)
+##    variables [input].
+##    [input]read: or current read -- what we see from the input pin HIGH (1) untouched or LOW (1) depressed
+##    [input]prev: or previous read – assigned to current reading at the end of the method
+##    [input]state: the stored state HIGH (1) or LOW (0)
+##    [input]time: the time when we last had a true
+##    millis: number of milliseconds since the Arduino began running the current program
+
+## So….
+
+##    If HIGH and the [input]read was LOW (button was depressed since the last time we looped) AND If millis() - [input]time  > 200
+##    Flip the state
+##    And assign [input]time millis()
+##    Else Set the pin to [input]state 
+##    Assign [input]prev to [input]read
+
+## abstract summary:
+
+##    So 99%+ of the time, we always see a HIGH (unless the button is pushed)
+##    If the button is pushed, we record this LOW to [input]prev, so the next time we enter the loop and the button is not being pushed we see true as long as millis() minus the [input]time of the last toggle is greater the 200 (adjust, which can be set with an adjust option)
+
+
+######################
+
+
+add_debounce_struct
+
+# increase the debounce_setting, increase if the output flickers 
+# need docs..
+# and testing
+#
+# remember these are being called from the loop (typically)
+# 
+# NOTE: if two buttons are controlling one output, today, strange
+#       things will happen since each button tries to assert its own state
+#       suggestion: we can fix this with an array of structs for shared outputs
+#       ie: output_pin 5, :as => :yellow_led, :shared => :yes # default no
+#       this would put the state at the output which could be compared to 
+#       the inputs_state and override and set it if different
+
+
+
+int toggle(int output)
+{
+  return toggle_output(output);
+}
+
+int toggle_output(int output)
+{
+  if (dbce[output].state == HIGH)
+    dbce[output].state = LOW;
+  else
+    dbce[output].state = HIGH;
+    digitalWrite(output, dbce[output].state);
+
+    return dbce[output].state;
+}
+
+
+int read_input(int input)
+{
+  int state = LOW;
+  dbce[input].read = digitalRead(input);
+
+  if (dbce[input].read == HIGH && dbce[input].prev == LOW && millis() - dbce[input].time > dbce[input].adjust)
+     {
+      dbce[input].time = millis();
+      state = HIGH;
+    }
+  else 
+    state = LOW;
+    
+      dbce[input].prev = dbce[input].read;
+      return state;
+}
+
+
+int toggle(int input, int output)
+{
+  return read_and_toggle(input, output);
+}
+
+int read_and_toggle(int input, int output)
+{
+  dbce[input].read = digitalRead(input);
+  // did we just release a button which was depressed the last time we checked and over 200 millseconds has passed since this statement was last true?
+  if (dbce[input].read == HIGH && dbce[input].prev == LOW && millis() - dbce[input].time > dbce[input].adjust) {
+    // ... flip the output
+    if (dbce[input].state == HIGH)
+      dbce[input].state = LOW;
+    else
+      dbce[input].state = HIGH;
+
+    /* save time of last press */
+    dbce[input].time = millis();    
+  }
+
+  digitalWrite(output, dbce[input].state);
+
+  dbce[input].prev = dbce[input].read;
+  
+  return dbce[input].state; 
+}
+
+    
+end

data/lib/plugins/debug_output_to_lcd.rb

@@ -0,0 +1,71 @@
+class DebugOutputToLcd < 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 "unsigned long start_loop_time = 0;", "unsigned long total_loop_time = 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
+
+# need a nice home for these
+
+
+
+
+
+void send_servo_debug_to_lcd(int servo)
+{
+  lcd_first_line();
+  Serial.print("pw ");
+  Serial.print( find_servo_pulse_width(servo));
+  Serial.print(" lp ");
+  Serial.print( find_servo_last_pulse(servo));
+  Serial.print("s");
+  Serial.print( find_servo_start_pulse(servo));
+//  Serial.print(" t");
+//  Serial.print( find_debounce_time(servo));
+
+  lcd_second_line();
+  Serial.print("d");
+//  Serial.print( millis() - find_debounce_time(servo));
+  Serial.print(" m");
+  Serial.print(millis());
+  
+}
+
+
+void send_button_debug_to_lcd(int button)
+{
+  
+  lcd_first_line();
+  Serial.print("r");
+  Serial.print( find_debounce_read(button));
+  Serial.print("p");
+  Serial.print( find_debounce_prev(button));
+  Serial.print("s");
+  Serial.print( find_debounce_state(button));
+  Serial.print(" t");
+  Serial.print( find_debounce_time(button));
+
+  lcd_second_line();
+  Serial.print("d");
+  Serial.print( millis() - find_debounce_time(button));
+  Serial.print(" m");
+  Serial.print(millis());
+  
+}
+
+
+
+
+end

data/lib/plugins/hysteresis.rb

@@ -0,0 +1,52 @@
+class Hysteresis < ArduinoPlugin
+  
+# jdbarnhart
+# 20080728
+#
+#
+# purpose
+#
+# add hysteresis to analog readings, typically sensors or potentiometers
+#
+# use
+# two steps
+#
+#  one
+#    declare :device => :sensor 
+#    example:
+#      input_pin 1, :as => :sensor_one, :device => :sensor
+#
+#  two
+#    instead of:
+#      my_lcd.print analogRead sensor_two
+#      use add_hyst
+#      my_lcd.print sensor_one.with_hyst 4
+#      
+#      # note, 4 is the amount of hysteresis
+#
+#
+void with_hysteresis(int pin, int amt)
+{
+  with_hyst(pin, amt);
+}
+
+int with_hyst(int pin, int amt)
+{
+  int read;
+  unsigned int i;
+  read = analogRead(pin);
+  for (i = 0; i < (int) (sizeof(hyst) / sizeof(hyst[0])); i++) {   
+    if (pin == hyst[i].pin) {
+      if (((read - hyst[i].state) > amt ) || ((hyst[i].state - read) > amt )) {
+        hyst[i].state = read;
+        return hyst[i].state;
+      } 
+      else
+        return hyst[i].state;      
+    }
+  }
+}
+
+
+
+end

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/lcd_padding.rb

@@ -0,0 +1,58 @@
+class LCDPadding < ArduinoPlugin
+  
+# jdbarnhart
+# 20080729
+#
+#
+# purpose
+
+# simple integer padding for lcd display pad
+#
+# example
+# my_lcd.print pad_int_to_str 29, 5
+# 
+# result
+# "   29"
+  
+
+
+static char* pad_int_to_str(int num, int length) 
+{
+    int i = 0;
+    int start;
+    char plain[20];
+    char space[5] = "  ";
+    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;
+}
+
+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/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/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