madrona-rad 0.2.4 → 0.2.5

data/lib/libraries/Wire/twi.h

@@ -0,0 +1,57 @@
+/*
+  twi.h - TWI/I2C library for Wiring & Arduino
+  Copyright (c) 2006 Nicholas Zambetti.  All right reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef twi_h
+#define twi_h
+
+  #include <inttypes.h>
+
+  //#define ATMEGA8
+
+  #ifndef CPU_FREQ
+  #define CPU_FREQ 16000000L
+  #endif
+
+  #ifndef TWI_FREQ
+  #define TWI_FREQ 100000L
+  #endif
+
+  #ifndef TWI_BUFFER_LENGTH
+  #define TWI_BUFFER_LENGTH 32
+  #endif
+
+  #define TWI_READY 0
+  #define TWI_MRX   1
+  #define TWI_MTX   2
+  #define TWI_SRX   3
+  #define TWI_STX   4
+  
+  void twi_init(void);
+  void twi_setAddress(uint8_t);
+  uint8_t twi_readFrom(uint8_t, uint8_t*, uint8_t);
+  uint8_t twi_writeTo(uint8_t, uint8_t*, uint8_t, uint8_t);
+  uint8_t twi_transmit(uint8_t*, uint8_t);
+  void twi_attachSlaveRxEvent( void (*)(uint8_t*, int) );
+  void twi_attachSlaveTxEvent( void (*)(void) );
+  void twi_reply(uint8_t);
+  void twi_stop(void);
+  void twi_releaseBus(void);
+
+#endif
+

data/lib/plugins/bitwise_ops.rb

@@ -0,0 +1,54 @@
+class BitwiseOps < 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
+ 
+  # add to external variables
+ 
+  # add the following to the setup method
+  # add_to_setup 
+
+
+int build_int(int hibyte, int lobyte) {
+    return((hibyte << 8) + lobyte);
+}
+
+int i_shiftleft(int val, int shift) {
+    return(val << shift);
+}
+
+int i_shiftright(int val, int shift) {
+    return(val >> shift);
+}
+
+byte b_shiftleft(byte val, byte shift) {
+    return(val << shift);
+}
+
+byte b_shiftright(byte val, byte shift) {
+    return(val >> shift);
+}
+
+int bit_and(int val, int mask) {
+    return(val & mask);
+}
+
+int bit_or(int val, int mask) {
+    return(val | mask);
+}
+
+int bit_xor(int val, int mask) {
+    return(val ^ mask);
+}
+
+int twos_comp(int val) {
+    return((val ^ 0xffff) + 1);
+}
+
+end

data/lib/plugins/blink_m.rb

@@ -1,11 +1,9 @@
 class BlinkM < ArduinoPlugin
 
 # scaffolding for blink_m
+include_wire
 
-
-
-
-
+add_blink_m_struct
 
 void simply_blink(void)
 {
@@ -13,13 +11,313 @@ void simply_blink(void)
 }   
 
 
-static void clear_blinkm( void )
+static void wire_begin(void) 
+{
+  delay(200);
+	Wire.begin();
+}
+
+static void stop_script( void )
 {
+  Wire.begin();
   Wire.beginTransmission(0x09);
-  Wire.send('c');
+  Wire.send('o');
   Wire.endTransmission();
 }
 
+// Call this first (when powering BlinkM from a power supply)
+
+static void BlinkM_begin()
+{
+    Wire.begin();                // join i2c bus (address optional for master)
+}
+
+// General version of BlinkM_beginWithPower().
+// Call this first when BlinkM is plugged directly into Arduino
+
+static void BlinkM_beginWithPowerPins(byte pwrpin, byte gndpin)
+{
+    DDRC |= _BV(pwrpin) | _BV(gndpin);
+    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
+
+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)
+{
+    if( Wire.available() ) {
+        for( int i=0; i<len; i++) 
+            resp[i] = Wire.receive();
+        return 0;
+    }
+    return -1;
+}
+
+// Sets the I2C address of the Arduino.  
+// 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(30);
+}
+
+
+// Gets the I2C addrss of the Arduino
+// 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
+
+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_startScript(byte addr)
+{
+    Wire.beginTransmission(addr);
+    Wire.send('p');
+    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)
+{
+    Serial.print("\nwriting line:");  Serial.print(pos,DEC);
+    Serial.print(" with cmd:"); Serial.print(cmd); 
+    Serial.print(" arg1:"); Serial.println(arg1,HEX);
+    
+    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)
+{
+    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);
+}
+
+
+
+
+
+
+
+
 
 
 end

data/lib/plugins/debounce.rb

@@ -25,6 +25,35 @@ class Debounce < ArduinoPlugin
   
 # 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
 
@@ -41,9 +70,7 @@ add_debounce_struct
 #       this would put the state at the output which could be compared to 
 #       the inputs_state and override and set it if different
 
-## Todo: reduce to two methods named read_input and read_and_toggle
 
-# consider adding "toggle" method that points to toggle_output
 
 int toggle(int output)
 {
@@ -61,41 +88,36 @@ int toggle_output(int output)
     return dbce[output].state;
 }
 
-int read_input(int input)
-{
-  return debounce_read(input);
-}
-
 
-int debounce_read(int input)
+int read_input(int input)
 {
-  struct debounce btn = dbce[input];
-  /* input is HIGH (1) for open and LOW (0) for closed circuit */
+  int state = LOW;
   dbce[input].read = digitalRead(input);
-  if (btn.read == LOW && millis() - btn.time > btn.adjust) {
+
+  if (dbce[input].read == HIGH && dbce[input].prev == LOW && millis() - dbce[input].time > dbce[input].adjust)
+     {
       dbce[input].time = millis();
-      return HIGH;
-  }
-  else {      
-      return LOW;
-  }
-  dbce[input].prev = btn.read;
+      state = HIGH;
+    }
+  else 
+    state = LOW;
+    
+      dbce[input].prev = dbce[input].read;
+      return state;
 }
 
 
-int read_and_toggle(int input, int output)
+int toggle(int input, int output)
 {
-  return debounce_toggle(input, output);
+  return read_and_toggle(input, output);
 }
 
-int debounce_toggle(int input, int output)
+int read_and_toggle(int input, int output)
 {
   dbce[input].read = digitalRead(input);
-
-  /* if we just pressed the button  */
-  /* and we've waited long enough since the last press to ignore any noise...  */
+  // 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) {
-    // ... invert the output
+    // ... flip the output
     if (dbce[input].state == HIGH)
       dbce[input].state = LOW;
     else