neo_rad 0.4.0

data/lib/libraries/LoopTimer/LoopTimer.h

@@ -0,0 +1,34 @@
+/*
+  LoopTime.h - - Loop Timer library for Wiring/Arduino - Version 0.1
+  
+  Original code by JD Banrhart
+  Original Arduino Library by BB Riley
+
+*/
+
+// ensure this library description is only included once
+#ifndef LoopTimer_h
+#define LoopTimer_h
+
+// include types & constants of Wiring core API
+#include "WConstants.h"
+
+// library interface description
+class LoopTimer {
+  public:
+    // constructors:
+	LoopTimer();
+	
+    // track method
+    void track(void);
+
+    // mover method:
+    unsigned long get_total(void);
+
+  private:
+	unsigned long start_loop_time;
+	unsigned long total_loop_time;
+};
+
+#endif
+

data/lib/libraries/LoopTimer/keywords.txt

@@ -0,0 +1,27 @@
+#######################################
+# Syntax Coloring Map For Test
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+LoopTimer	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+track	KEYWORD2
+get_total	KEYWORD2
+
+
+######################################
+# Instances (KEYWORD2)
+#######################################
+
+
+
+#######################################
+# Constants (LITERAL1)
+#######################################

data/lib/libraries/OneWire/OneWire.cpp

@@ -0,0 +1,194 @@
+/*
+
+// -----------------------------------------------------------
+// This is an 'abbreviated' OneWire Library with functions
+// only to handle a single device per line, no ROM-IDs will 
+// be read. It is a subset of the original fom the Arduino
+// IDE - Brian Riley, Underhill Center, VT July 2008
+// -----------------------------------------------------------
+Copyright (c) 2007, Jim Studt
+
+Updated to work with arduino-0008 and to include skip() as of
+2007/07/06. --RJL20
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Much of the code was inspired by Derek Yerger's code, though I don't
+think much of that remains.  In any event that was..
+    (copyleft) 2006 by Derek Yerger - Free to distribute freely.
+
+The CRC code was excerpted and inspired by the Dallas Semiconductor 
+sample code bearing this copyright.
+//---------------------------------------------------------------------------
+// Copyright (C) 2000 Dallas Semiconductor Corporation, All Rights Reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY,  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL DALLAS SEMICONDUCTOR BE LIABLE FOR ANY CLAIM, DAMAGES
+// OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+// OTHER DEALINGS IN THE SOFTWARE.
+//
+// Except as contained in this notice, the name of Dallas Semiconductor
+// shall not be used except as stated in the Dallas Semiconductor
+// Branding Policy.
+//--------------------------------------------------------------------------
+*/
+
+#include "OneWire.h"
+
+extern "C" {
+#include "WConstants.h"
+#include <avr/io.h>
+#include "pins_arduino.h"
+}
+
+
+OneWire::OneWire( uint8_t pinArg)
+{
+    pin = pinArg;
+    port = digitalPinToPort(pin);
+    bitmask =  digitalPinToBitMask(pin);
+    outputReg = portOutputRegister(port);
+    inputReg = portInputRegister(port);
+    modeReg = portModeRegister(port);
+}
+
+//
+// Perform the onewire reset function.  We will wait up to 250uS for
+// the bus to come high, if it doesn't then it is broken or shorted
+// and we return a 0;
+//
+// Returns 1 if a device asserted a presence pulse, 0 otherwise.
+//
+uint8_t OneWire::reset() {
+    uint8_t r;
+    uint8_t retries = 125;
+
+    // wait until the wire is high... just in case
+    pinMode(pin,INPUT);
+    do {
+	if ( retries-- == 0) return 0;
+	delayMicroseconds(2); 
+    } while( !digitalRead( pin));
+    
+    digitalWrite(pin,0);   // pull low for 500uS
+    pinMode(pin,OUTPUT);
+    delayMicroseconds(500);
+    pinMode(pin,INPUT);
+    delayMicroseconds(65);
+    r = !digitalRead(pin);
+    delayMicroseconds(490);
+    return r;
+}
+
+//
+// Write a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+void OneWire::write_bit(uint8_t v) {
+    static uint8_t lowTime[] = { 55, 5 };
+    static uint8_t highTime[] = { 5, 55};
+    
+    v = (v&1);
+    *modeReg |= bitmask;  // make pin an output, do first since we
+                          // expect to be at 1
+    *outputReg &= ~bitmask; // zero
+    delayMicroseconds(lowTime[v]);
+    *outputReg |= bitmask; // one, push pin up - important for
+                           // parasites, they might start in here
+    delayMicroseconds(highTime[v]);
+}
+
+//
+// Read a bit. Port and bit is used to cut lookup time and provide
+// more certain timing.
+//
+uint8_t OneWire::read_bit() {
+    uint8_t r;
+    
+    *modeReg |= bitmask;    // make pin an output, do first since we expect to be at 1
+    *outputReg &= ~bitmask; // zero
+    delayMicroseconds(1);
+    *modeReg &= ~bitmask;     // let pin float, pull up will raise
+    delayMicroseconds(5);          // A "read slot" is when 1mcs > t > 2mcs
+    r = ( *inputReg & bitmask) ? 1 : 0; // check the bit
+    delayMicroseconds(50);        // whole bit slot is 60-120uS, need to give some time
+    
+    return r;
+}
+
+//
+// Write a byte. The writing code uses the active drivers to raise the
+// pin high, if you need power after the write (e.g. DS18S20 in
+// parasite power mode) then set 'power' to 1, otherwise the pin will
+// go tri-state at the end of the write to avoid heating in a short or
+// other mishap.
+//
+void OneWire::write(uint8_t v, uint8_t power) {
+    uint8_t bitMask;
+    
+    for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+	OneWire::write_bit( (bitMask & v)?1:0);
+    }
+    if ( !power) {
+	pinMode(pin,INPUT);
+	digitalWrite(pin,0);
+    }
+}
+
+//
+// Read a byte
+//
+uint8_t OneWire::read() {
+    uint8_t bitMask;
+    uint8_t r = 0;
+    
+    for (bitMask = 0x01; bitMask; bitMask <<= 1) {
+	if ( OneWire::read_bit()) r |= bitMask;
+    }
+    return r;
+}
+
+
+//
+// Do a ROM skip
+//
+void OneWire::skip()
+{
+    write(0xCC,0);         // Skip ROM
+}
+
+void OneWire::depower()
+{
+    pinMode(pin,INPUT);
+}
+

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

@@ -0,0 +1,296 @@
+/*
+  SWSerLCDpa.cpp - 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
+*/
+
+/******************************************************************************
+ * Includes
+ ******************************************************************************/
+
+#include "WConstants.h"
+#include "SWSerLCDpa.h"
+
+/******************************************************************************
+ * Definitions
+ ******************************************************************************/
+
+/******************************************************************************
+ * Constructors
+ ******************************************************************************/
+
+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
+ ******************************************************************************/
+
+void SWSerLCDpa::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 SWSerLCDpa::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 SWSerLCDpa::print(const char *s)
+{
+  while (*s) {
+    print(*s++);
+    delay(2);
+  }
+}
+
+void SWSerLCDpa::print(char c)
+{
+  print((uint8_t) c);
+}
+
+void SWSerLCDpa::print(int n)
+{
+  print((long) n);
+}
+
+void SWSerLCDpa::print(unsigned int n)
+{
+  print((unsigned long) n);
+}
+
+void SWSerLCDpa::print(long n)
+{
+  if (n < 0) {
+    print('-');
+    n = -n;
+  }
+  printNumber(n, 10);
+}
+
+void SWSerLCDpa::print(unsigned long n)
+{
+  printNumber(n, 10);
+}
+
+void SWSerLCDpa::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 SWSerLCDpa::clearscr(void)
+{
+  print("?f");
+  delay(30);
+}
+
+void SWSerLCDpa::clearscr(const char *s)
+{
+	clearscr();
+    print(s);
+}
+
+void SWSerLCDpa::clearscr(int n)
+{
+	clearscr();
+    print(n);
+}
+
+void SWSerLCDpa::clearscr(long n, int base)
+{
+	clearscr();
+	print(n, base);
+}
+
+
+void SWSerLCDpa::clearline(int line)
+{
+  setxy(0,line);
+  print("?l");
+  delay(20);
+}
+
+void SWSerLCDpa::clearline(int line, const char *s)
+{
+  clearline(line);
+  print(s);
+}
+
+void SWSerLCDpa::clearline(int line, int n)
+{
+  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)
+{
+  print("?y");
+  print(y);	
+  print("?x");
+  if (x < 10)
+    print('0');
+  print(x);
+  delay(10);
+}
+
+void SWSerLCDpa::setxy(int x, int y, const char *s)
+{
+	setxy(x,y);
+	print(s);
+}
+
+void SWSerLCDpa::setxy(int x, int y, int n)
+{
+	setxy(x,y);
+	print(n);
+}
+
+void SWSerLCDpa::setxy(int x, int y, long n, int base)
+{
+	setxy(x,y);
+	print(n, base);
+}
+
+void SWSerLCDpa::home(void)
+{
+  print("?a");
+  delay(10);
+}
+
+void SWSerLCDpa::home(const char *s)
+{
+  home();
+  print(s);
+}
+
+void SWSerLCDpa::home(int n)
+{
+  home();
+  print(n);
+}
+
+void SWSerLCDpa::home(long n, int base)
+{
+	home();
+	print(n, base);
+}
+
+void SWSerLCDpa::setgeo(int geometry)
+{
+	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 /////////////////////////////////////////////////////////////
+
+void SWSerLCDpa::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(2);
+  }
+  
+}