madrona-rad 0.2.7 → 0.3.1

data/lib/examples/hello_xbee.rb

@@ -0,0 +1,12 @@
+class HelloXbee < ArduinoSketch
+  
+  output_pin 13, :as => :led
+  
+  serial_begin
+  def loop
+    led.blink 200
+    serial_print "...testing..."
+    delay 1000
+  end
+  
+end

data/lib/examples/midi_beat_box.rb

@@ -0,0 +1,86 @@
+class MidiBeatBox < ArduinoSketch
+  
+  # midi synthesiser output on channel 2
+  # with speed controlled by spectra soft pot
+
+    @channel = 2
+    input_pin 1, :as => :sensor_one, :device => :spectra
+    output_pin 13, :as => :led
+
+    serial_begin :rate => 31250
+
+    def setup
+      delay 3000
+    end
+
+    def loop
+      8.times {first}
+      2.times do 
+        second
+        third
+      end
+      4.times {first}
+      2.times {second}
+    end
+    
+    def first
+      play 39, 52, 37
+      play  0,  0,  0
+      play 36, 52,  0
+      play 37, 52, 39
+
+      play 37,  0,  0
+      play 36,  0,  0
+      play 39, 50,  0
+      play  0,  0,  0
+
+      play 52, 36, 37
+      play 0,  0,   0
+      play 39,  0,  0
+      play 36, 37,  0
+
+      play 36, 37, 39
+      play 36, 38,  0
+      play 50,  0,  0
+      play 0,   0,  0
+    end
+    
+    def second
+      play 39, 52, 37
+      play 36,  0,  0
+      play  0,  0,  0
+      play 37, 52, 39
+
+      play 38,  0,  0
+      play 36,  0,  0
+      play 39, 50,  0
+      play  0,  0,  0
+    end
+    
+    def third
+      play  0, 36, 37
+      play  0,  0,   0
+      play 39, 36,  0
+      play 36, 37, 50
+
+      play 36, 37, 39
+      play 36, 37,  0
+      play 50,  0,  0
+      play 39,  0,  0
+    end
+    
+
+    def play(one, two, three)
+      n = 1 + one + two + three # ack to coerce parameters to int
+      note_on(@channel, one, 127) unless one == 0
+      note_on(@channel, two, 127) unless two == 0
+      note_on(@channel, three, 127) unless three == 0
+      delay 310 - sensor_one.soft_lock # start slowly 
+      note_off(@channel, one, 0) unless one == 0
+      note_off(@channel, two, 0) unless two == 0
+      note_off(@channel, three, 0) unless three == 0
+    end
+    
+
+    
+end

data/lib/examples/midi_scales.rb

@@ -0,0 +1,94 @@
+class MidiScales < ArduinoSketch
+  
+# purpose
+# trigger midi output with buttons and
+# spectra soft pots
+#
+#
+
+
+  @current_note = int
+  @last_note_one = 0
+  @last_note_two = 0
+  @last_note_three = 0
+  @note = int
+
+  input_pin 1, :as => :sensor_one, :device => :spectra
+  input_pin 2, :as => :sensor_two, :device => :spectra
+  input_pin 3, :as => :sensor_three, :device => :spectra
+  input_pin 7, :as => :button_one, :device => :button
+  input_pin 8, :as => :button_two, :device => :button
+  input_pin 9, :as => :button_three, :device => :button
+  output_pin 13, :as => :led
+
+  serial_begin :rate => 31250
+
+  def setup
+    delay 3000
+  end
+
+  def loop
+    change_tone if button_one.read_input
+    change_pressure if button_two.read_input
+    change_channels if button_three.read_input
+    read_sensor_one
+    read_sensor_two
+    read_sensor_three
+  end
+     
+  def change_tone 
+    110.upto(127) do |note|
+      play 0, note, 127
+    end
+  end
+
+  def change_pressure
+    110.upto(127) do |pressure| 
+       play 0, 45, pressure
+    end
+  end
+     
+  def change_channels 
+    0.upto(6) do |channel| 
+      play channel, 50, 100
+    end
+  end
+
+  def read_sensor_one
+    @current_note = sensor_one.soft_lock
+    pre_play(@current_note, @last_note_one, 13)
+    @last_note_one = @current_note
+  end
+
+  def read_sensor_two
+    @current_note = sensor_two.soft_lock
+    pre_play(@current_note, @last_note_two, 14)
+    @last_note_two = @current_note
+  end
+
+  def read_sensor_three
+    @current_note = sensor_three.soft_lock
+    pre_play(@current_note, @last_note_three, 15)
+    @last_note_three = @current_note
+  end
+
+  def pre_play(current_note, last_note, channel) # warning, don't use last as a parameter...
+    n = 1 + channel
+    unless current_note == last_note
+      @note = ((current_note /16) + 40)
+      play_with_no_delay( channel, @note, 100 )
+    end
+  end
+    
+  def play(chan, note, pressure)
+    note_on(chan, note, pressure)
+    delay 100 # adjust to need
+    note_off(chan, note, 0)
+  end
+  
+  def play_with_no_delay(chan, note, pressure) # note is not turned off
+    note_on(chan, note, pressure)
+  end
+
+
+end

data/lib/examples/servo_throttle.rb

@@ -1,12 +1,15 @@
 class ServoThrottle < ArduinoSketch
-  
+
+     # updated 20080731 
+     # replaced external variables with instance style variables
+     
      # potentiometer to control servo
      # with a bit of hysteresis
      # use analog pin for sensor
      # need to format the output of sensor_position and sensor_amount
 
-     
-     external_vars :sensor_position => "int, 0", :servo_amount => "int, 0"
+     @sensor_position = 0
+     @servo_amount = 0
 
      output_pin 5, :as => :my_lcd, :device => :sf_lcd
      input_pin 1, :as => :sensor
@@ -16,9 +19,9 @@ class ServoThrottle < ArduinoSketch
        def loop
          servo_refresh
          #delay 9 # comment out if using servo status, since it will add enough delay
-         sensor_position = analogRead(sensor)
-         servo_amount = (add_hysteresis(sensor_position, 10)*0.36)
-         my_servo.position servo_amount
+         @sensor_position = analogRead(sensor)
+         @servo_amount = (add_hysteresis(@sensor_position, 10)*0.36)
+         my_servo.position @servo_amount
          servo_status
          
        end
@@ -28,9 +31,9 @@ class ServoThrottle < ArduinoSketch
         my_lcd.setxy 0,0			# line 0, col 0
      		my_lcd.print "Read  Send"
      		my_lcd.setxy 0,1		# line 1, col 0
-     		my_lcd.print sensor_position # need method of blanking out previous reading
+     		my_lcd.print @sensor_position # need method of blanking out previous reading
      		my_lcd.setxy 6,1 
-     		my_lcd.print servo_amount
+     		my_lcd.print @servo_amount
        end
 
   

data/lib/examples/software_serial.rb

@@ -0,0 +1,10 @@
+class SoftwareSerial < ArduinoSketch
+  output_pin 13, :as => :led
+  software_serial 6, 7, :as => :gps
+  serial_begin
+
+  def loop
+    digitalWrite(led, true)
+    serial_print(gps.read)
+  end
+end

data/lib/examples/twitter.rb

@@ -0,0 +1,57 @@
+class Twitter < ArduinoSketch
+  
+  #include <avr/io.h>
+  #include <string.h>
+
+
+
+  define "TWEETLEN 141"
+  define "HOSTNAME www.twitter.com"
+  
+  define 'IPADDR "128.121.146.100"'  # twitter.com
+  define "PORT 80"                 # // HTTP
+  define "HTTPPATH /atduskgreg/"    # // the person we want to follow
+  
+
+  define "TWEETLEN 141"
+  array "char linebuffer[256]" # // our large buffer for data
+  array "char tweet[TWEETLEN]" # // the tweet
+  @lines = 0
+
+  
+  define "XPORT_RXPIN 2"
+  define "XPORT_TXPIN 3"
+  define "XPORT_RESETPIN 4"
+  define "XPORT_DTRPIN 5"
+  define "XPORT_CTSPIN 6"
+  define "XPORT_RTSPIN 7"
+  
+
+  @errno = 0
+  @laststatus = 0
+  @currstatus = 0
+
+
+  
+# in setup
+#xport = AF_XPort(XPORT_RX, XPORT_TX, XPORT_RESET, XPORT_DTR, XPORT_RTS, XPORT_CTS)
+  
+  
+  output_pin 10, :as => :shield, :device => :ethernet
+  
+  serial_begin :rate => 57600
+  
+  def loop
+    
+#  local_connect()
+    # kind of a problem... fixed
+    get_tweet
+    fetchtweet
+    delay 30000
+
+
+  end
+  
+
+  
+end

data/lib/libraries/AFSoftSerial/AFSoftSerial.cpp

@@ -0,0 +1,321 @@
+/*
+  SoftwareSerial.cpp - Software serial library
+  Copyright (c) 2006 David A. Mellis.  All right reserved. - hacked by ladyada 
+
+  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
+*/
+
+/******************************************************************************
+ * Includes
+ ******************************************************************************/
+#include <avr/interrupt.h>
+#include "WConstants.h"
+#include "AFSoftSerial.h"
+
+/******************************************************************************
+ * Definitions
+ ******************************************************************************/
+
+#define AFSS_MAX_RX_BUFF 64
+
+/******************************************************************************
+ * Statics
+ ******************************************************************************/
+static uint8_t _receivePin;
+static uint8_t _transmitPin;
+static int _bitDelay;
+
+static char _receive_buffer[AFSS_MAX_RX_BUFF]; 
+static uint8_t _receive_buffer_index;
+
+#if (F_CPU == 16000000)
+void whackDelay(uint16_t delay) { 
+  uint8_t tmp=0;
+
+  asm volatile("sbiw    %0, 0x01 \n\t"
+	       "ldi %1, 0xFF \n\t"
+	       "cpi %A0, 0xFF \n\t"
+	       "cpc %B0, %1 \n\t"
+	       "brne .-10 \n\t"
+	       : "+r" (delay), "+a" (tmp)
+	       : "0" (delay)
+	       );
+}
+#endif
+
+/******************************************************************************
+ * Interrupts
+ ******************************************************************************/
+
+SIGNAL(SIG_PIN_CHANGE0) {
+  if ((_receivePin >=8) && (_receivePin <= 13)) {
+    recv();
+  }
+}
+SIGNAL(SIG_PIN_CHANGE2)
+{
+  if (_receivePin <8) {
+    recv();
+  }
+}
+
+
+void recv(void) { 
+  char i, d = 0; 
+  if (digitalRead(_receivePin)) 
+    return;       // not ready! 
+  whackDelay(_bitDelay - 8);
+  for (i=0; i<8; i++) { 
+    //PORTB |= _BV(5); 
+    whackDelay(_bitDelay*2 - 6);  // digitalread takes some time
+    //PORTB &= ~_BV(5); 
+    if (digitalRead(_receivePin)) 
+      d |= (1 << i); 
+   } 
+  whackDelay(_bitDelay*2);
+  if (_receive_buffer_index >=  AFSS_MAX_RX_BUFF)
+    return;
+  _receive_buffer[_receive_buffer_index] = d; // save data 
+  _receive_buffer_index++;  // got a byte 
+} 
+  
+
+
+/******************************************************************************
+ * Constructors
+ ******************************************************************************/
+
+AFSoftSerial::AFSoftSerial(uint8_t receivePin, uint8_t transmitPin)
+{
+  _receivePin = receivePin;
+  _transmitPin = transmitPin;
+  _baudRate = 0;
+}
+
+void AFSoftSerial::setTX(uint8_t tx) {
+  _transmitPin = tx;
+}
+void AFSoftSerial::setRX(uint8_t rx) {
+  _receivePin = rx;
+}
+
+/******************************************************************************
+ * User API
+ ******************************************************************************/
+
+void AFSoftSerial::begin(long speed)
+{
+  pinMode(_transmitPin, OUTPUT);
+  digitalWrite(_transmitPin, HIGH);
+
+  pinMode(_receivePin, INPUT); 
+  digitalWrite(_receivePin, HIGH);  // pullup!
+
+  _baudRate = speed;
+  switch (_baudRate) {
+  case 115200: // For xmit -only-!
+    _bitDelay = 4; break;
+  case 57600:
+    _bitDelay = 14; break;
+  case 38400:
+    _bitDelay = 24; break;
+  case 31250:
+    _bitDelay = 31; break;
+  case 19200:
+    _bitDelay = 54; break;
+  case 9600:
+    _bitDelay = 113; break;
+  case 4800:
+    _bitDelay = 232; break;
+  case 2400:
+    _bitDelay = 470; break;
+  default:
+    _bitDelay = 0;
+  }    
+
+   if (_receivePin < 8) {
+     // a PIND pin, PCINT16-23
+     PCMSK2 |= _BV(_receivePin);
+     PCICR |= _BV(2);
+  } else if (_receivePin <= 13) {
+    // a PINB pin, PCINT0-5
+    PCICR |= _BV(0);    
+    PCMSK0 |= _BV(_receivePin-8);
+  } 
+
+  whackDelay(_bitDelay*2); // if we were low this establishes the end
+}
+
+int AFSoftSerial::read(void)
+{
+  uint8_t d,i;
+
+  if (! _receive_buffer_index)
+    return -1;
+
+  d = _receive_buffer[0]; // grab first byte
+  // if we were awesome we would do some nifty queue action
+  // sadly, i dont care
+  for (i=0; i<_receive_buffer_index; i++) {
+    _receive_buffer[i] = _receive_buffer[i+1];
+  }
+  _receive_buffer_index--;
+  return d;
+}
+
+uint8_t AFSoftSerial::available(void)
+{
+  return _receive_buffer_index;
+}
+
+void AFSoftSerial::print(uint8_t b)
+{
+  if (_baudRate == 0)
+    return;
+  byte mask;
+
+  cli();  // turn off interrupts for a clean txmit
+
+  digitalWrite(_transmitPin, LOW);  // startbit
+  whackDelay(_bitDelay*2);
+
+  for (mask = 0x01; mask; mask <<= 1) {
+    if (b & mask){ // choose bit
+      digitalWrite(_transmitPin,HIGH); // send 1
+    }
+    else{
+      digitalWrite(_transmitPin,LOW); // send 1
+    }
+    whackDelay(_bitDelay*2);
+  }
+  
+  digitalWrite(_transmitPin, HIGH);
+  sei();  // turn interrupts back on. hooray!
+  whackDelay(_bitDelay*2);
+}
+
+void AFSoftSerial::print(const char *s)
+{
+  while (*s)
+    print(*s++);
+}
+
+void AFSoftSerial::print(char c)
+{
+  print((uint8_t) c);
+}
+
+void AFSoftSerial::print(int n)
+{
+  print((long) n);
+}
+
+void AFSoftSerial::print(unsigned int n)
+{
+  print((unsigned long) n);
+}
+
+void AFSoftSerial::print(long n)
+{
+  if (n < 0) {
+    print('-');
+    n = -n;
+  }
+  printNumber(n, 10);
+}
+
+void AFSoftSerial::print(unsigned long n)
+{
+  printNumber(n, 10);
+}
+
+void AFSoftSerial::print(long n, int base)
+{
+  if (base == 0)
+    print((char) n);
+  else if (base == 10)
+    print(n);
+  else
+    printNumber(n, base);
+}
+
+void AFSoftSerial::println(void)
+{
+  print('\r');
+  print('\n');  
+}
+
+void AFSoftSerial::println(char c)
+{
+  print(c);
+  println();  
+}
+
+void AFSoftSerial::println(const char c[])
+{
+  print(c);
+  println();
+}
+
+void AFSoftSerial::println(uint8_t b)
+{
+  print(b);
+  println();
+}
+
+void AFSoftSerial::println(int n)
+{
+  print(n);
+  println();
+}
+
+void AFSoftSerial::println(long n)
+{
+  print(n);
+  println();  
+}
+
+void AFSoftSerial::println(unsigned long n)
+{
+  print(n);
+  println();  
+}
+
+void AFSoftSerial::println(long n, int base)
+{
+  print(n, base);
+  println();
+}
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+void AFSoftSerial::printNumber(unsigned long n, uint8_t base)
+{
+  unsigned char buf[8 * sizeof(long)]; // Assumes 8-bit chars. 
+  unsigned long i = 0;
+
+  if (n == 0) {
+    print('0');
+    return;
+  } 
+
+  while (n > 0) {
+    buf[i++] = n % base;
+    n /= base;
+  }
+
+  for (; i > 0; i--)
+    print((char) (buf[i - 1] < 10 ? '0' + buf[i - 1] : 'A' + buf[i - 1] - 10));
+}