rad 0.2.2 → 0.2.9

data/lib/libraries/OneWire/OneWire.h

@@ -0,0 +1,63 @@
+#ifndef OneWire_h
+#define OneWire_h
+
+#include <inttypes.h>
+
+// you can exclude onewire_search by defining that to 0
+#ifndef ONEWIRE_SEARCH
+#define ONEWIRE_SEARCH 0
+#endif
+
+// You can exclude onewire_crc16 by defining that to 0
+#ifndef ONEWIRE_CRC16
+#define ONEWIRE_CRC16 0
+#endif
+
+class OneWire
+{
+  private:
+    uint8_t pin;
+    uint8_t port;
+    uint8_t bitmask;
+    volatile uint8_t *outputReg;
+    volatile uint8_t *inputReg;
+    volatile uint8_t *modeReg;
+
+  public:
+    OneWire( uint8_t pin);
+    
+    // Perform a 1-Wire reset cycle. Returns 1 if a device responds
+    // with a presence pulse.  Returns 0 if there is no device or the
+    // bus is shorted or otherwise held low for more than 250uS
+    uint8_t reset();
+
+    // Issue a 1-Wire rom skip command, to address all on bus.
+    void skip();
+
+    // Write a byte. If 'power' is one then the wire is held high at
+    // the end for parasitically powered devices. You are responsible
+    // for eventually depowering it by calling depower() or doing
+    // another read or write.
+    void write( uint8_t v, uint8_t power = 0);
+
+    // Read a byte.
+    uint8_t read();
+
+    // Write a bit. The bus is always left powered at the end, see
+    // note in write() about that.
+    void write_bit( uint8_t v);
+
+    // Read a bit.
+    uint8_t read_bit();
+
+    // Stop forcing power onto the bus. You only need to do this if
+    // you used the 'power' flag to write() or used a write_bit() call
+    // and aren't about to do another read or write. You would rather
+    // not leave this powered if you don't have to, just in case
+    // someone shorts your bus.
+    void depower();
+
+
+};
+
+#endif

data/lib/libraries/OneWire/keywords.txt

@@ -0,0 +1,35 @@
+#######################################
+# Syntax Coloring Map For OneWire
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+OneWire	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+reset	KEYWORD2
+write_bit	KEYWORD2
+read_bit	KEYWORD2
+write	KEYWORD2
+read	KEYWORD2
+select	KEYWORD2
+skip	KEYWORD2
+depower	KEYWORD2
+reset_search	KEYWORD2
+search	KEYWORD2
+crc8	KEYWORD2
+crc16	KEYWORD2
+
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################

data/lib/libraries/OneWire/readme.txt

@@ -0,0 +1,13 @@
+See:
+    http://www.arduino.cc/playground/Learning/OneWire
+    http://www.federated.com/~jim/onewire/
+
+The version of the OneWire library at federated.com works with arduino-0007.
+The version here works with arduino-0008, thanks to the very helpful Jim Studt.
+
+To use, make a new directory: arduino-0008/lib/targets/libraries/OneWire/
+and put OneWire.cpp, OneWire.h and keywords.txt in it.
+
+--Josh Larios
+hades (at) elsewhere (dot) org
+2007/07/06

data/lib/libraries/SWSerLCDpa/SWSerLCDpa.cpp

@@ -37,8 +37,20 @@ SWSerLCDpa::SWSerLCDpa(uint8_t transmitPin)
 {
   _transmitPin = transmitPin;
   _baudRate = 0;
+  pinMode(_transmitPin, OUTPUT);
+  _geometry = 0;
 }
 
+SWSerLCDpa::SWSerLCDpa(uint8_t transmitPin, int geometry)
+{
+  _transmitPin = transmitPin;
+  _baudRate = 0;
+  pinMode(_transmitPin, OUTPUT); 
+  _geometry = geometry;
+}
+
+
+
 /******************************************************************************
  * User API
  ******************************************************************************/
@@ -50,6 +62,9 @@ void SWSerLCDpa::begin(long speed)
 
   digitalWrite(_transmitPin, HIGH);
   delayMicroseconds( _bitPeriod); // if we were low this establishes the end
+  delay(50);
+  if (_geometry)
+	setgeo(_geometry);
 }
 
 void SWSerLCDpa::print(uint8_t b)
@@ -81,7 +96,7 @@ void SWSerLCDpa::print(const char *s)
 {
   while (*s) {
     print(*s++);
-    delay(1);
+    delay(2);
   }
 }
 
@@ -125,51 +140,57 @@ void SWSerLCDpa::print(long n, int base)
 }
 
 // -------- PHA unique codes -------------------------
-void SWSerLCDpa::println(void)
-{
-  print("?n");
-  delay(10);
-}
+
 
 void SWSerLCDpa::clearscr(void)
 {
   print("?f");
-  delay(100);
+  delay(30);
 }
 
-void SWSerLCDpa::home(void)
+void SWSerLCDpa::clearscr(const char *s)
 {
-  print("?a");
-  delay(10);
+	clearscr();
+    print(s);
 }
 
+void SWSerLCDpa::clearscr(int n)
+{
+	clearscr();
+    print(n);
+}
 
-void SWSerLCDpa::setgeo(int geometry)
+void SWSerLCDpa::clearscr(long n, int base)
 {
-  print("?G");
-  print(geometry);
-  delay(200);
+	clearscr();
+	print(n, base);
 }
 
-void SWSerLCDpa::setintensity(int intensity)
+
+void SWSerLCDpa::clearline(int line)
 {
-  print("?B");
-  if (intensity < 16)
-  	print('0');
-  print(intensity, 16);
-  delay(200);
+  setxy(0,line);
+  print("?l");
+  delay(20);
 }
 
-void SWSerLCDpa::intoBignum(void)
+void SWSerLCDpa::clearline(int line, const char *s)
 {
-  print("?>3");
+  clearline(line);
+  print(s);
 }
 
-void SWSerLCDpa::outofBignum(void)
+void SWSerLCDpa::clearline(int line, int n)
 {
-  print("?<");
+  clearline(line);
+  print(n);
 }
 
+void SWSerLCDpa::clearline(int line, long n, int base)
+{
+	clearline(line);
+	print(n, base);
+}
 
 void SWSerLCDpa::setxy(int x, int y)
 {
@@ -182,47 +203,72 @@ void SWSerLCDpa::setxy(int x, int y)
   delay(10);
 }
 
+void SWSerLCDpa::setxy(int x, int y, const char *s)
+{
+	setxy(x,y);
+	print(s);
+}
 
-void SWSerLCDpa::println(char c)
+void SWSerLCDpa::setxy(int x, int y, int n)
 {
-  print(c);
-  println();  
+	setxy(x,y);
+	print(n);
 }
 
-void SWSerLCDpa::println(const char c[])
+void SWSerLCDpa::setxy(int x, int y, long n, int base)
 {
-  print(c);
-  println();
+	setxy(x,y);
+	print(n, base);
 }
 
-void SWSerLCDpa::println(uint8_t b)
+void SWSerLCDpa::home(void)
 {
-  print(b);
-  println();
+  print("?a");
+  delay(10);
 }
 
-void SWSerLCDpa::println(int n)
+void SWSerLCDpa::home(const char *s)
 {
-  print(n);
-  println();
+  home();
+  print(s);
 }
 
-void SWSerLCDpa::println(long n)
+void SWSerLCDpa::home(int n)
 {
+  home();
   print(n);
-  println();  
 }
 
-void SWSerLCDpa::println(unsigned long n)
+void SWSerLCDpa::home(long n, int base)
 {
-  print(n);
-  println();  
+	home();
+	print(n, base);
 }
 
-void SWSerLCDpa::println(long n, int base)
+void SWSerLCDpa::setgeo(int geometry)
 {
-  print(n, base);
-  println();
+	print("?G");
+	print(geometry);
+	delay(200);
+}
+
+void SWSerLCDpa::setintensity(int intensity)
+{
+  print("?B");
+  if (intensity < 16)
+  	print('0');
+  print(intensity, 16);
+  delay(200);
+}
+
+void SWSerLCDpa::intoBignum(void)
+{
+  print("?>3");
+}
+
+void SWSerLCDpa::outofBignum(void)
+{
+  print("?<");
 }
 
 // Private Methods /////////////////////////////////////////////////////////////
@@ -242,9 +288,9 @@ void SWSerLCDpa::printNumber(unsigned long n, uint8_t base)
     n /= base;
   }
 
-  for (; i > 0; i--)
+  for (; i > 0; i--) {
     print((char) (buf[i - 1] < 10 ? '0' + buf[i - 1] : 'A' + buf[i - 1] - 10));
-  
-  delay(8);
+	delay(2);
+  }
   
 }

data/lib/libraries/SWSerLCDpa/SWSerLCDpa.h

@@ -29,8 +29,10 @@ class SWSerLCDpa
     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);
@@ -41,21 +43,26 @@ class SWSerLCDpa
     void print(long);
     void print(unsigned long);
     void print(long, int);
-    void println(void);
 	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);
-	void setxy(int, int);
-    void println(char);
-    void println(const char[]);
-    void println(uint8_t);
-    void println(int);
-    void println(long);
-    void println(unsigned long);
-    void println(long, int);
 };
 
 #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);
+  
+}