rad 0.2.2 → 0.2.9

data/lib/libraries/SWSerLCDsf/SWSerLCDsf.h

@@ -0,0 +1,67 @@
+/*
+  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 clearscr(const char[]);
+	void clearscr(int);
+	void clearscr(long, int);
+	void home(void);
+	void home(const char[]);
+	void home(int);
+	void home(long, int);
+	void setxy(byte, byte);
+	void setxy(byte, byte, const char[]);
+	void setxy(byte, byte, int);
+	void setxy(byte, byte, long, int);
+	void setgeo(int);
+	void setintensity(int);
+	void setcmd(byte, byte);
+};
+
+#endif
+

data/lib/libraries/Servo/Servo.cpp

@@ -0,0 +1,192 @@
+/*
+  Servo.h - Arduino Software Servo Library
+  Author: ????
+  Modified: Brian Riley <brianbr@wulfden.org> Jun/Jul 2008
+  Copyright (c) 2007 David A. Mellis.  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
+*/
+
+#include "WConstants.h"
+#include <Servo.h>
+
+Servo *Servo::first;
+
+#define NO_ANGLE (0xff)
+
+Servo::Servo() : pin(0),angle(NO_ANGLE),pulse0(0),min16(DEFLT_MINP),max16(DEFLT_MAXP),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);
+    return 1;
+}
+
+uint8_t Servo::attach(int pinArg, int angleArg)
+{
+	attach(pinArg);
+	write(angleArg);
+    return 1;
+}
+
+
+uint8_t Servo::attach(int pinArg, uint16_t minp, uint16_t maxp)
+{
+	attach(pinArg);
+    min16	= minp/16;
+    max16	= maxp/16;
+    return 1;
+}
+
+uint8_t Servo::attach(int pinArg, int angleArg, uint16_t minp, uint16_t maxp)
+{
+	attach(pinArg);
+    min16	= minp/16;
+    max16	= maxp/16;
+	write(angleArg);
+    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,61 @@
+/*
+  Servo.h - Arduino Software Servo Library
+  Author: ????
+  Modified: Brian Riley <brianbr@wulfden.org> Jun/Jul 2008
+  Copyright (c) 2007 David A. Mellis.  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 SERVO_IS_IN
+#define SERVO_IS_IN
+
+#include <inttypes.h>
+#include <wiring.h>
+
+#define	DEFLT_MINP	34
+#define	DEFLT_MAXP	150
+
+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 DEFLT_MINP)
+    uint8_t max16;       // maximum pulse, 16uS units, 0-4ms range (default is DEFLT_MAXP)
+    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,int);
+                             // same, except position is also is specified
+    uint8_t attach(int,uint16_t,uint16_t);
+                             // same, except min/max pulse is specified
+    uint8_t attach(int,int,uint16_t,uint16_t);
+                             // same, except position and min/max pulse is specified
+    void detach();
+    void position(int);		 // enter an angle from 0 to 180
+    void speed(int);		 // enter a speed from -90 to +90
+    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/Stepper/Stepper.cpp

@@ -0,0 +1,220 @@
+/*
+  Stepper.cpp - - Stepper library for Wiring/Arduino - Version 0.4
+  
+  Original library     (0.1) by Tom Igoe.
+  Two-wire modifications   (0.2) by Sebastian Gassner
+  Combination version   (0.3) by Tom Igoe and David Mellis
+  Bug fix for four-wire   (0.4) by Tom Igoe, bug fix from Noah Shibley  
+
+  Drives a unipolar or bipolar stepper motor using  2 wires or 4 wires
+
+  When wiring multiple stepper motors to a microcontroller,
+  you quickly run out of output pins, with each motor requiring 4 connections. 
+
+  By making use of the fact that at any time two of the four motor
+  coils are the inverse  of the other two, the number of
+  control connections can be reduced from 4 to 2. 
+
+  A slightly modified circuit around a Darlington transistor array or an L293 H-bridge
+  connects to only 2 microcontroler pins, inverts the signals received,
+  and delivers the 4 (2 plus 2 inverted ones) output signals required
+  for driving a stepper motor.
+
+  The sequence of control signals for 4 control wires is as follows:
+
+  Step C0 C1 C2 C3
+     1  1  0  1  0
+     2  0  1  1  0
+     3  0  1  0  1
+     4  1  0  0  1
+
+  The sequence of controls signals for 2 control wires is as follows
+  (columns C1 and C2 from above):
+
+  Step C0 C1
+     1  0  1
+     2  1  1
+     3  1  0
+     4  0  0
+
+  The circuits can be found at 
+ 
+http://www.arduino.cc/en/Tutorial/Stepper
+ 
+ 
+ */
+
+
+#include "WProgram.h"
+#include "Stepper.h"
+
+/*
+ * two-wire constructor.
+ * Sets which wires should control the motor.
+ */
+Stepper::Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2)
+{
+  this->step_number = 0;      // which step the motor is on
+  this->speed = 0;        // the motor speed, in revolutions per minute
+  this->direction = 0;      // motor direction
+  this->last_step_time = 0;    // time stamp in ms of the last step taken
+  this->number_of_steps = number_of_steps;    // total number of steps for this motor
+  
+  // Arduino pins for the motor control connection:
+  this->motor_pin_1 = motor_pin_1;
+  this->motor_pin_2 = motor_pin_2;
+
+  // setup the pins on the microcontroller:
+  pinMode(this->motor_pin_1, OUTPUT);
+  pinMode(this->motor_pin_2, OUTPUT);
+  
+  // When there are only 2 pins, set the other two to 0:
+  this->motor_pin_3 = 0;
+  this->motor_pin_4 = 0;
+  
+  // pin_count is used by the stepMotor() method:
+  this->pin_count = 2;
+}
+
+
+/*
+ *   constructor for four-pin version
+ *   Sets which wires should control the motor.
+ */
+
+Stepper::Stepper(int number_of_steps, int motor_pin_1, int motor_pin_2, int motor_pin_3, int motor_pin_4)
+{
+  this->step_number = 0;      // which step the motor is on
+  this->speed = 0;        // the motor speed, in revolutions per minute
+  this->direction = 0;      // motor direction
+  this->last_step_time = 0;    // time stamp in ms of the last step taken
+  this->number_of_steps = number_of_steps;    // total number of steps for this motor
+  
+  // Arduino pins for the motor control connection:
+  this->motor_pin_1 = motor_pin_1;
+  this->motor_pin_2 = motor_pin_2;
+  this->motor_pin_3 = motor_pin_3;
+  this->motor_pin_4 = motor_pin_4;
+
+  // setup the pins on the microcontroller:
+  pinMode(this->motor_pin_1, OUTPUT);
+  pinMode(this->motor_pin_2, OUTPUT);
+  pinMode(this->motor_pin_3, OUTPUT);
+  pinMode(this->motor_pin_4, OUTPUT);
+
+  // pin_count is used by the stepMotor() method:  
+  this->pin_count = 4;  
+}
+
+/*
+  Sets the speed in revs per minute
+
+*/
+void Stepper::set_speed(long whatSpeed)
+{
+  this->step_delay = 60L * 1000L / this->number_of_steps / whatSpeed;
+}
+
+/*
+  Moves the motor steps_to_move steps.  If the number is negative, 
+   the motor moves in the reverse direction.
+ */
+void Stepper::set_steps(int steps_to_move)
+{  
+  int steps_left = abs(steps_to_move);  // how many steps to take
+  
+  // determine direction based on whether steps_to_mode is + or -:
+  if (steps_to_move > 0) {this->direction = 1;}
+  if (steps_to_move < 0) {this->direction = 0;}
+    
+    
+  // decrement the number of steps, moving one step each time:
+  while(steps_left > 0) {
+  // move only if the appropriate delay has passed:
+  if (millis() - this->last_step_time >= this->step_delay) {
+      // step the motor to step number 0, 1, 2, or 3:
+      stepMotor(this->step_number % 4);
+      // get the timeStamp of when you stepped:
+      this->last_step_time = millis();
+      // increment or decrement the step number,
+      // depending on direction:
+      if (this->direction == 1) {
+        this->step_number++;
+        if (this->step_number == this->number_of_steps) {
+          this->step_number = 0;
+        }
+      } 
+      else { 
+        if (this->step_number == 0) {
+          this->step_number = this->number_of_steps;
+        }
+        this->step_number--;
+      }
+      // decrement the steps left:
+      steps_left--;
+    }
+  }
+}
+
+/*
+ * Moves the motor forward or backwards.
+ */
+void Stepper::stepMotor(int thisStep)
+{
+  if (this->pin_count == 2) {
+    switch (thisStep) {
+      case 0: /* 01 */
+      digitalWrite(motor_pin_1, LOW);
+      digitalWrite(motor_pin_2, HIGH);
+      break;
+      case 1: /* 11 */
+      digitalWrite(motor_pin_1, HIGH);
+      digitalWrite(motor_pin_2, HIGH);
+      break;
+      case 2: /* 10 */
+      digitalWrite(motor_pin_1, HIGH);
+      digitalWrite(motor_pin_2, LOW);
+      break;
+      case 3: /* 00 */
+      digitalWrite(motor_pin_1, LOW);
+      digitalWrite(motor_pin_2, LOW);
+      break;
+    } 
+  }
+  if (this->pin_count == 4) {
+    switch (thisStep) {
+      case 0:    // 1010
+      digitalWrite(motor_pin_1, HIGH);
+      digitalWrite(motor_pin_2, LOW);
+      digitalWrite(motor_pin_3, HIGH);
+      digitalWrite(motor_pin_4, LOW);
+      break;
+      case 1:    // 0110
+      digitalWrite(motor_pin_1, LOW);
+      digitalWrite(motor_pin_2, HIGH);
+      digitalWrite(motor_pin_3, HIGH);
+      digitalWrite(motor_pin_4, LOW);
+      break;
+      case 2:    //0101
+      digitalWrite(motor_pin_1, LOW);
+      digitalWrite(motor_pin_2, HIGH);
+      digitalWrite(motor_pin_3, LOW);
+      digitalWrite(motor_pin_4, HIGH);
+      break;
+      case 3:    //1001
+      digitalWrite(motor_pin_1, HIGH);
+      digitalWrite(motor_pin_2, LOW);
+      digitalWrite(motor_pin_3, LOW);
+      digitalWrite(motor_pin_4, HIGH);
+      break;
+    } 
+  }
+}
+
+/*
+  version() returns the version of the library:
+*/
+int Stepper::version(void)
+{
+  return 4;
+}