neo_rad 0.4.0

data/lib/plugins/blink_m.rb

@@ -0,0 +1,356 @@
+class BlinkM < ArduinoPlugin
+
+#
+#
+#  BlinkM_funcs.h -- Arduino library to control BlinkM
+#  --------------
+#
+#
+#  Note: original version of this file lives with the BlinkMTester sketch
+#
+#  2007, Tod E. Kurt, ThingM, http://thingm.com/
+#
+#  version: 20080203
+#
+#  history:
+#   20080101 - initial release
+#   20080203 - added setStartupParam(), bugfix receiveBytes() from Dan Julio
+#   20080727 - ported to rad jd barnhart
+#
+#   first step, declare output pin 19 as i2c
+##  output_pin 19, :as => :wire, :device => :i2c, :enable => :true # reminder, true issues wire.begin
+
+
+include_wire
+
+add_blink_m_struct
+
+
+
+# Not needed when pin is declared with :enable => :true 
+# In fact, declaring it twice causes nothing but problems
+
+static void BlinkM_begin()
+{
+    Wire.begin();                // join i2c bus (address optional for master)
+}
+
+
+// General version of BlinkM_beginWithPower().
+
+static void BlinkM_beginWithPowerPins(byte pwrpin, byte gndpin)
+{
+    DDRC |= _BV(pwrpin) | _BV(gndpin);  // make outputs
+    PORTC &=~ _BV(gndpin);
+    PORTC |=  _BV(pwrpin);
+    delay(100);  // wait for things to stabilize
+
+    Wire.begin();
+}
+
+// Call this first when BlinkM is plugged directly into Arduino
+// 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()
+{
+    BlinkM_beginWithPowerPins( PC3, PC2 );
+}
+
+// sends a generic command
+
+static void BlinkM_sendCmd(byte addr, byte* cmd, int cmdlen)
+{
+    Wire.beginTransmission(addr);
+    for( byte i=0; i<cmdlen; i++) 
+        Wire.send(cmd[i]);
+    Wire.endTransmission();
+}
+
+// receives generic data
+// returns 0 on success, and -1 if no data available
+// note: responsiblity of caller to know how many bytes to expect
+
+static int BlinkM_receiveBytes(byte addr, byte* resp, byte len)
+{
+    Wire.requestFrom(addr, len);
+    if( Wire.available() ) {
+        for( int i=0; i<len; i++) 
+            resp[i] = Wire.receive();
+        return 0;
+    }
+    return -1;
+}
+
+// Sets the I2C address of the BlinkM(s)
+// Typically used to setup BlinkM addresses
+// Connect one and call this with an address like 10, 
+// then 11 for the next and so on and so forth 
+// Uses "general call" broadcast address
+
+static void BlinkM_setAddress(byte newaddress)
+{
+  Wire.beginTransmission(0x00);  // general call (broadcast address)
+  Wire.send('A');
+  Wire.send(newaddress);
+  Wire.send(0xD0);
+  Wire.send(0x0D);  // dood!
+  Wire.send(newaddress);
+  Wire.endTransmission();
+  delay(50); // just in case
+}
+
+
+// Gets the I2C addrss of the BlinkM
+// Kind of redundant when sent to a specific address
+// but uses to verify BlinkM communication
+
+static int BlinkM_getAddress(byte addr)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('a');
+    Wire.endTransmission();
+    Wire.requestFrom(addr, (byte)1);
+    if( Wire.available() ) {
+        byte b = Wire.receive();
+        return b; 
+    }
+    return -1;
+}
+
+// Gets the BlinkM firmware version
+
+static int BlinkM_getVersion(byte addr)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('Z');
+    Wire.endTransmission();
+    Wire.requestFrom(addr, (byte)2);
+    if( Wire.available() ) {
+        byte major_ver = Wire.receive();
+        byte minor_ver = Wire.receive();
+        return (major_ver<<8) + minor_ver;
+    }
+    return -1;
+}
+
+// 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
+{
+    char message[50];
+    char status[5];
+    strcpy(message, "received 0x");
+    //Serial.print("Checking BlinkM address...");
+    int b = BlinkM_getAddress(addr);
+    if( b==-1 ) {
+        //Serial.println("No response, that's not good");
+        return "No response, that's not good";  // no response
+    } 
+    itoa(b, status ,16);
+    
+    //Serial.print("received addr: 0x");
+    //Serial.print(b,HEX);
+    if( b != addr )
+        return "error, mismatch"; // error, addr mismatch 
+    else 
+        return strcat(message, status); // match, everything okay
+}
+
+// Demonstrates how to verify you-re talking to a BlinkM 
+// and that you know its address -- digital version
+
+static int BlinkM_checkAddress(byte addr)
+{
+    //Serial.print("Checking BlinkM address...");
+    int b = BlinkM_getAddress(addr);
+    if( b==-1 ) {
+        //Serial.println("No response, that's not good");
+        return -1;  // no response
+    } 
+    
+    //Serial.print("received addr: 0x");
+    //Serial.print(b,HEX);
+    if( b != addr )
+        return 1; // error, addr mismatch 
+    else 
+        return 0; // match, everything okay
+}
+
+// Sets the speed of fading between colors.  
+// Higher numbers means faster fading, 255 == instantaneous fading
+
+static void BlinkM_setFadeSpeed(byte addr, byte fadespeed)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('f');
+    Wire.send(fadespeed);
+    Wire.endTransmission();  
+}
+
+// Sets the light script playback time adjust
+// The timeadj argument is signed, and is an additive value to all
+// durations in a light script. Set to zero to turn off time adjust.
+
+static void BlinkM_setTimeAdj(byte addr, byte timeadj)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('t');
+    Wire.send(timeadj);
+    Wire.endTransmission();  
+}
+
+// Fades to an RGB color
+
+static void BlinkM_fadeToRGB(byte addr, byte red, byte grn, byte blu)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('c');
+    Wire.send(red);
+    Wire.send(grn);
+    Wire.send(blu);
+    Wire.endTransmission();
+}
+
+// Fades to an HSB color
+
+static void BlinkM_fadeToHSB(byte addr, byte hue, byte saturation, byte brightness)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('h');
+    Wire.send(hue);
+    Wire.send(saturation);
+    Wire.send(brightness);
+    Wire.endTransmission();
+}
+
+// Sets an RGB color immediately
+
+static void BlinkM_setRGB(byte addr, byte red, byte grn, byte blu)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('n');
+    Wire.send(red);
+    Wire.send(grn);
+    Wire.send(blu);
+    Wire.endTransmission();
+}
+
+// Fades to a random RGB color
+
+static void BlinkM_fadeToRandomRGB(byte addr, byte rrnd, byte grnd, byte brnd)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('C');
+    Wire.send(rrnd);
+    Wire.send(grnd);
+    Wire.send(brnd);
+    Wire.endTransmission();
+}
+// Fades to a random HSB color
+
+static void BlinkM_fadeToRandomHSB(byte addr, byte hrnd, byte srnd, byte brnd)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('H');
+    Wire.send(hrnd);
+    Wire.send(srnd);
+    Wire.send(brnd);
+    Wire.endTransmission();
+}
+
+static void BlinkM_getRGBColor(byte addr, byte* r, byte* g, byte* b)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('g');
+    Wire.endTransmission();
+    Wire.requestFrom(addr, (byte)3);
+    if( Wire.available() ) {
+        *r = Wire.receive();
+        *g = Wire.receive();
+        *b = Wire.receive();
+    }
+}
+
+static void BlinkM_playScript(byte addr, byte script_id, byte reps, byte pos)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('p');
+    Wire.send(script_id);
+    Wire.send(reps);
+    Wire.send(pos);
+    Wire.endTransmission();
+}
+
+static void BlinkM_stopScript(byte addr)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('o');
+    Wire.endTransmission();
+}
+
+static void BlinkM_setScriptLengthReps(byte addr, byte script_id, 
+                                       byte len, byte reps)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('L');
+    Wire.send(script_id);
+    Wire.send(len);
+    Wire.send(reps);
+    Wire.endTransmission();
+}
+
+static void BlinkM_writeScriptLine(byte addr, byte script_id, 
+                                   byte pos, byte dur,
+                                   byte cmd, byte arg1, byte arg2, byte arg3)
+{
+#ifdef BLINKM_FUNCS_DEBUG
+    Serial.print("writing line:");  Serial.print(pos,DEC);
+    Serial.print(" with cmd:"); Serial.print(cmd); 
+    Serial.print(" arg1:"); Serial.println(arg1,HEX);
+#endif
+    Wire.beginTransmission(addr);
+    Wire.send('W');
+    Wire.send(script_id);
+    Wire.send(pos);
+    Wire.send(dur);
+    Wire.send(cmd);
+    Wire.send(arg1);
+    Wire.send(arg2);
+    Wire.send(arg3);
+    Wire.endTransmission();
+}
+
+static void BlinkM_writeScript(byte addr, byte script_id, 
+                               byte len, byte reps,
+                               blinkm_script_line* lines)
+{
+#ifdef BLINKM_FUNCS_DEBUG
+    Serial.print("writing script to addr:"); Serial.print(addr,DEC);
+    Serial.print(", script_id:"); Serial.println(script_id,DEC);
+#endif
+    for(byte i=0; i < len; i++) {
+        blinkm_script_line l = lines[i];
+        BlinkM_writeScriptLine( addr, script_id, i, l.dur,
+                                l.cmd[0], l.cmd[1], l.cmd[2], l.cmd[3]);
+    }
+    BlinkM_setScriptLengthReps(addr, script_id, len, reps);
+}
+
+
+static void BlinkM_setStartupParams(byte addr, byte mode, byte script_id,
+                                    byte reps, byte fadespeed, byte timeadj)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('B');
+    Wire.send(mode);
+    Wire.send(script_id);
+    Wire.send(reps);
+    Wire.send(fadespeed);
+    Wire.send(timeadj);
+    Wire.endTransmission();
+} 
+
+
+end

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