madrona-rad 0.2.2

data/lib/libraries/SWSerLCDsf/SWSerLCDsf.cpp

@@ -0,0 +1,254 @@
+/*
+  SWSerLCDsf.cpp - Software serial to SparkFun controller chip based
+  LCD display library Adapted from SoftwareSerial.cpp (c) 2006 David A. Mellis
+  by Brian B. Riley, Underhill Center, Vermont, USA, July 2008
+
+  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 "WConstants.h"
+#include "SWSerLCDsf.h"
+
+/******************************************************************************
+ * Definitions
+ ******************************************************************************/
+
+/******************************************************************************
+ * Constructors
+ ******************************************************************************/
+
+SWSerLCDsf::SWSerLCDsf(uint8_t transmitPin)
+{
+  _transmitPin = transmitPin;
+  _baudRate = 0;
+  _rows = 2;
+  _cols = 16;
+  _geometry = 0;
+}
+
+SWSerLCDsf::SWSerLCDsf(uint8_t transmitPin, int geometry)
+{
+  _transmitPin = transmitPin;
+  _baudRate = 0;
+  pinMode(_transmitPin, OUTPUT); 
+  _rows = 2;
+  _cols = 16;
+  _geometry = geometry;
+}
+
+
+/******************************************************************************
+ * User API
+ ******************************************************************************/
+
+void SWSerLCDsf::begin(long speed)
+{
+  _baudRate = speed;
+  _bitPeriod = 1000000 / _baudRate;
+
+  digitalWrite(_transmitPin, HIGH);
+  delayMicroseconds( _bitPeriod); // if we were low this establishes the end
+  delay(20);
+  clearscr();
+  if (_geometry)
+  	setgeo(_geometry);
+}
+
+void SWSerLCDsf::print(uint8_t b)
+{
+  if (_baudRate == 0)
+    return;
+    
+  int bitDelay = _bitPeriod - clockCyclesToMicroseconds(50); // a digitalWrite is about 50 cycles
+  byte mask;
+
+  digitalWrite(_transmitPin, LOW);
+  delayMicroseconds(bitDelay);
+
+  for (mask = 0x01; mask; mask <<= 1) {
+    if (b & mask){ // choose bit
+      digitalWrite(_transmitPin,HIGH); // send 1
+    }
+    else{
+      digitalWrite(_transmitPin,LOW); // send 1
+    }
+    delayMicroseconds(bitDelay);
+  }
+
+  digitalWrite(_transmitPin, HIGH);
+  delayMicroseconds(bitDelay);
+}
+
+void SWSerLCDsf::print(const char *s)
+{
+  while (*s) {
+    print(*s++);
+    delay(1);
+  }
+}
+
+void SWSerLCDsf::print(char c)
+{
+  print((uint8_t) c);
+}
+
+void SWSerLCDsf::print(int n)
+{
+  print((long) n);
+}
+
+void SWSerLCDsf::print(unsigned int n)
+{
+  print((unsigned long) n);
+}
+
+void SWSerLCDsf::print(long n)
+{
+  if (n < 0) {
+    print('-');
+    n = -n;
+  }
+  printNumber(n, 10);
+}
+
+void SWSerLCDsf::print(unsigned long n)
+{
+  printNumber(n, 10);
+}
+
+void SWSerLCDsf::print(long n, int base)
+{
+  if (base == 0)
+    print((char) n);
+  else if (base == 10)
+    print(n);
+  else
+    printNumber(n, base);
+}
+
+// -------- PHA unique codes -------------------------
+
+void SWSerLCDsf::clearscr(void)
+{
+  print((uint8_t) 0xFE);
+  print((uint8_t) 0x01);
+  delay(100);
+}
+
+void SWSerLCDsf::home(void)
+{
+  print((uint8_t) 0xFE);
+  print((uint8_t) 0x80);
+  delay(10);
+}
+
+void SWSerLCDsf::setcmd(byte code, byte cmd)
+{
+  print((uint8_t) code);
+  print((uint8_t) cmd);	
+}
+
+
+void SWSerLCDsf::setgeo(int geometry)
+{
+  byte	rows=6, cols=4;
+  switch (geometry) {
+    case 216:
+  	  break;
+    case 220:
+	    _cols = 20;
+  		cols = 3;
+  		break;
+    case 416:
+    	rows = 5;
+  		_rows = 4;
+  		break;
+  	case 420:
+	    _rows = 4;
+    	_cols = 20;
+  		cols = 3;
+  		rows = 5;
+  		break;
+  	default:
+	  	return;
+	  	break;
+  }
+  print((uint8_t) 0x7C);
+  print((uint8_t) rows);
+  print((uint8_t) 0x7C);
+  print((uint8_t) cols);
+  delay(200);
+}
+
+void SWSerLCDsf::setintensity(int intensity)
+{
+  if (intensity > 29)
+  	intensity = 29;
+  print((uint8_t) 0x7C);
+  print((uint8_t) (0x80 + intensity));
+  delay(100);
+}
+
+void SWSerLCDsf::setxy(byte x, byte y)
+{
+  byte posvar;
+  
+  switch (y) {
+    case 0:
+  		posvar = 128 + x;
+  		break;
+  	case 1:
+  		posvar = 192+ x;
+  		break;
+  	case 2:
+  		posvar = ((_cols == 16) ? 144 : 148) + x;
+  		break;
+  	case 3:
+  		posvar = ((_cols == 16) ? 208 : 212) + x;
+  		break;
+  }			
+  print((uint8_t) 0xFE);
+  print((uint8_t) posvar);	
+}
+
+
+
+// Private Methods /////////////////////////////////////////////////////////////
+
+void SWSerLCDsf::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));
+  
+  delay(8);
+  
+}

data/lib/libraries/SWSerLCDsf/SWSerLCDsf.h

@@ -0,0 +1,57 @@
+/*
+  SWSerLCDsf.h - Software serial to SparkFun controller chip based
+  LCD display library Adapted from SoftwareSerial.cpp (c) 2006 David A. Mellis
+  by Brian B. Riley, Underhill Center, Vermont, USA, July 2008
+
+  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 SWSerLCDsf_h
+#define SWSerLCDsf_h
+
+#include <inttypes.h>
+ 
+class SWSerLCDsf
+{
+  private:
+    uint8_t _transmitPin;
+    long _baudRate;
+    int _bitPeriod;
+    byte _rows;
+    byte _cols;
+    int _geometry;
+    void printNumber(unsigned long, uint8_t);
+  public:
+    SWSerLCDsf(uint8_t);
+    SWSerLCDsf(uint8_t, int);
+    void begin(long);
+    void print(char);
+    void print(const char[]);
+    void print(uint8_t);
+    void print(int);
+    void print(unsigned int);
+    void print(long);
+    void print(unsigned long);
+    void print(long, int);
+	void clearscr(void);
+	void home(void);
+	void setgeo(int);
+	void setintensity(int);
+	void setxy(byte, byte);
+	void setcmd(byte, byte);
+};
+
+#endif
+

data/lib/libraries/Servo/Servo.cpp

@@ -0,0 +1,152 @@
+#include "WConstants.h"
+#include <Servo.h>
+
+Servo *Servo::first;
+
+#define NO_ANGLE (0xff)
+
+Servo::Servo() : pin(0),angle(NO_ANGLE),pulse0(0),next(0)
+{}
+
+
+uint8_t Servo::attach(int pinArg)
+{
+    pin = pinArg;
+    angle = NO_ANGLE;
+    pulse0 = 0;
+    next = first;
+    first = this;
+    digitalWrite(pin,0);
+    pinMode(pin,OUTPUT);
+    min16	= 34;
+    max16	= 150;
+    return 1;
+}
+
+
+uint8_t Servo::attach(int pinArg, uint16_t minp, uint16_t maxp)
+{
+    pin = pinArg;
+    angle = NO_ANGLE;
+    pulse0 = 0;
+    next = first;
+    first = this;
+    digitalWrite(pin,0);
+    pinMode(pin,OUTPUT);
+    min16	= minp/16;
+    max16	= maxp/16;
+    return 1;
+}
+
+void Servo::detach()
+{
+    for ( Servo **p = &first; *p != 0; p = &((*p)->next) ) {
+	if ( *p == this) {
+	    *p = this->next;
+	    this->next = 0;
+	    return;
+	}
+    }
+}
+
+void Servo::write(int angleArg)
+{
+    if ( angleArg < 0) angleArg = 0;
+    if ( angleArg > 180) angleArg = 180;
+    angle = angleArg;
+    // bleh, have to use longs to prevent overflow, could be tricky if always a 16MHz clock, but not true
+    // That 64L on the end is the TCNT0 prescaler, it will need to change if the clock's prescaler changes,
+    // but then there will likely be an overflow problem, so it will have to be handled by a human.
+    pulse0 = (min16*16L*clockCyclesPerMicrosecond() + (max16-min16)*(16L*clockCyclesPerMicrosecond())*angle/180L)/64L;
+}
+
+void Servo::position(int angleArg)
+{
+    write(angleArg);
+}
+
+void Servo::speed(int speedVal)
+{
+	speedVal += 90;
+    write(speedVal);
+}
+
+uint8_t Servo::read()
+{
+    return angle;
+}
+
+uint8_t Servo::attached()
+{
+    for ( Servo *p = first; p != 0; p = p->next ) {
+	if ( p == this) return 1;
+    }
+    return 0;
+}
+
+/*************************************************
+ * refresh() - the heart of the method
+ *************************************************/
+
+void Servo::refresh()
+{
+    uint8_t count = 0, i = 0;
+    uint16_t base = 0;
+    Servo *p;
+    static unsigned long lastRefresh = 0;
+    unsigned long m = millis();
+
+    // if we haven't wrapped millis, and 20ms have not passed, then don't do anything
+    if ( m >= lastRefresh && m < lastRefresh + 20) return;
+    lastRefresh = m;
+
+    for ( p = first; p != 0; p = p->next ) if ( p->pulse0) count++;
+    if ( count == 0) return;
+  
+    // gather all the servos in an array
+    Servo *s[count];
+    for ( p = first; p != 0; p = p->next ) if ( p->pulse0) s[i++] = p;
+
+    // bubblesort the servos by pulse time, ascending order
+    for(;;) {
+	uint8_t moved = 0;
+	for ( i = 1; i < count; i++) {
+	    if ( s[i]->pulse0 < s[i-1]->pulse0) {
+		Servo *t = s[i];
+		s[i] = s[i-1];
+		s[i-1] = t;
+		moved = 1;
+	    }
+	}
+	if ( !moved) break;
+    }
+  
+    // turn on all the pins
+    // Note the timing error here... when you have many servos going, the
+    // ones at the front will get a pulse that is a few microseconds too long.
+    // Figure about 4uS/servo after them. This could be compensated, but I feel
+    // it is within the margin of error of software servos that could catch
+    // an extra interrupt handler at any time.
+    for ( i = 0; i < count; i++) digitalWrite( s[i]->pin, 1);
+
+    uint8_t start = TCNT0;
+    uint8_t now = start;
+    uint8_t last = now;
+  
+    // Now wait for each pin's time in turn..
+    for ( i = 0; i < count; i++) {
+	uint16_t go = start + s[i]->pulse0;
+    
+	// loop until we reach or pass 'go' time
+	for (;;) {
+	    now = TCNT0;
+	    if ( now < last) base += 256;
+	    last = now;
+  
+	    if ( base+now > go) {
+		digitalWrite( s[i]->pin,0);
+		break;
+	    }
+	}
+    }
+}

data/lib/libraries/Servo/Servo.h

@@ -0,0 +1,33 @@
+#ifndef SERVO_IS_IN
+#define SERVO_IS_IN
+
+#include <inttypes.h>
+#include <wiring.h>
+
+class Servo
+{
+  private:
+    uint8_t pin;
+    uint8_t angle;       // in degrees
+    uint16_t pulse0;     // pulse width in TCNT0 counts
+    uint8_t min16;       // minimum pulse, 16uS units  (default is 34)
+    uint8_t max16;       // maximum pulse, 16uS units, 0-4ms range (default is 150)
+    class Servo *next;
+    static Servo* first;
+    void write(int);         // specify the angle in degrees, 0 to 180
+ public:
+    Servo();
+    uint8_t attach(int);     // attach to a pin, sets pinMode, returns 0 on failure, won't
+                             // position the servo until a subsequent write() happens
+    uint8_t attach(int,uint16_t,uint16_t);
+                             // same, except min/max pulse is specified
+    void detach();
+    void position(int);		// enter an angle from 0 to 180
+    void speed(int);		// enter a speed from -100 to +100
+    uint8_t read();
+    uint8_t attached();
+    static void refresh();    // must be called at least every 50ms or so to keep servo alive
+                              // you can call more often, it won't happen more than once every 20ms
+};
+
+#endif

data/lib/libraries/Servo/keywords.txt

@@ -0,0 +1,25 @@
+#######################################
+# Syntax Coloring Map Servo
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+Servo  KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+attach KEYWORD2
+detach KEYWORD2
+write KEYWORD2
+read KEYWORD2
+attached KEYWORD2
+setMinimumPulse KEYWORD2
+setMaximumPulse KEYWORD2
+refresh KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

data/lib/plugins/debounce.rb

@@ -0,0 +1,116 @@
+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 
+
+
+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
+
+## 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)
+{
+  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)
+{
+  return debounce_read(input);
+}
+
+
+int debounce_read(int input)
+{
+  struct debounce btn = dbce[input];
+  /* input is HIGH (1) for open and LOW (0) for closed circuit */
+  dbce[input].read = digitalRead(input);
+  if (btn.read == LOW && millis() - btn.time > btn.adjust) {
+      dbce[input].time = millis();
+      return HIGH;
+  }
+  else {      
+      return LOW;
+  }
+  dbce[input].prev = btn.read;
+}
+
+
+int read_and_toggle(int input, int output)
+{
+  return debounce_toggle(input, output);
+}
+
+int debounce_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...  */
+  if (dbce[input].read == HIGH && dbce[input].prev == LOW && millis() - dbce[input].time > dbce[input].adjust) {
+    // ... invert 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