neo_rad 0.4.0

data/lib/libraries/SWSerLCDpa/SWSerLCDpa.h

@@ -0,0 +1,69 @@
+/*
+  SWSerLCDpa.h - Software serial to Peter Anderson controller chip based
+  LCD display library Adapted from SoftwareSerial.cpp (c) 2006 David A. Mellis
+  by Brian B. Riley, Underhill Center, Vermont, USA, July 2007
+
+  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 SWSerLCDpa_h
+#define SWSerLCDpa_h
+
+#include <inttypes.h>
+ 
+class SWSerLCDpa
+{
+  private:
+    uint8_t _transmitPin;
+    long _baudRate;
+    int _bitPeriod;
+    int _geometry;
+    void printNumber(unsigned long, uint8_t);
+  public:
+    SWSerLCDpa(uint8_t, int); 
+    SWSerLCDpa(uint8_t);
+    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 clearline(int);
+	void clearline(int, const char[]);
+	void clearline(int, int);
+	void clearline(int, long, int);
+	void home(void);
+	void home(const char[]);
+	void home(int);
+	void home(long, int);
+	void setxy(int, int);
+	void setxy(int, int, const char[]);
+	void setxy(int, int, int);
+	void setxy(int, int, long, int);
+	void setgeo(int);
+	void setintensity(int);
+	void intoBignum(void);
+	void outofBignum(void);
+};
+
+#endif
+

data/lib/libraries/SWSerLCDsf/SWSerLCDsf.cpp

@@ -0,0 +1,311 @@
+/*
+  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(50);
+  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);
+}
+
+// -------- Spark Fun unique codes -------------------------
+
+void SWSerLCDsf::clearscr(void)
+{
+  print((uint8_t) 0xFE);
+  print((uint8_t) 0x01);
+  delay(100);
+}
+
+void SWSerLCDsf::clearscr(const char *s)
+{
+	clearscr();
+	print(s);
+}
+
+void SWSerLCDsf::clearscr(int n)
+{
+	clearscr();
+	print(n);
+}
+
+void SWSerLCDsf::clearscr(long n, int b)
+{
+	clearscr();
+	print(n,b);
+}
+
+void SWSerLCDsf::home(void)
+{
+	setxy(0, 0);
+}
+
+void SWSerLCDsf::home(const char *s)
+{
+	home();
+	print(s);
+}
+
+void SWSerLCDsf::home(int n)
+{
+	home();
+	print(n);
+}
+
+void SWSerLCDsf::home(long n, int b)
+{
+	home();
+	print(n,b);
+}
+
+
+
+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);
+}
+
+void SWSerLCDsf::setxy(byte x, byte y, const char *s)
+{
+	setxy(x,y);
+	print(s);
+}
+
+void SWSerLCDsf::setxy(byte x, byte y, int n)
+{
+	setxy(x,y);
+	print(n);
+}
+
+void SWSerLCDsf::setxy(byte x, byte y, long n, int b)
+{
+	setxy(x,y);
+	print(n,b);
+}
+
+
+
+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);
+}
+
+
+
+
+
+// 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,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