neo_rad 0.4.0

data/lib/libraries/DS1307/DS1307.cpp

@@ -0,0 +1,162 @@
+extern "C" {
+#include <../Wire/Wire.h>
+}
+#include "DS1307.h"
+
+DS1307::DS1307()
+{
+  // Wire.begin();  // no no no no ..... do it explictly outside of library - multiple invocations is TROUBLE!!!!!  BBR
+}
+
+// DS1307 RTC=DS1307();
+
+// PRIVATE FUNCTIONS
+
+// Aquire data from the RTC chip in BCD format
+// refresh the buffer
+void DS1307::read(void)
+{
+  // use the Wire lib to connect to the rtc
+  // reset the register pointer to zero
+  Wire.beginTransmission(DS1307_CTRL_ID);
+    Wire.send(0x00);
+  Wire.endTransmission();
+
+  // request the 7 bytes of data    (secs, min, hr, dow, date, mth, yr) 
+  Wire.requestFrom(DS1307_CTRL_ID, 7);
+  for(int i=0; i<7; i++)
+  {
+    // store data in raw bcd format
+    rtc_bcd[i]=Wire.receive();
+  }
+}
+
+// update the data on the IC from the bcd formatted data in the buffer
+void DS1307::save(void)
+{
+  Wire.beginTransmission(DS1307_CTRL_ID);
+  Wire.send(0x00); // reset register pointer
+  for(int i=0; i<7; i++)
+  {
+    Wire.send(rtc_bcd[i]);
+  }
+  Wire.endTransmission();
+}
+
+
+// PUBLIC FUNCTIONS
+
+void DS1307::get(byte *rtc, boolean refresh)   // Aquire data from buffer and convert to int, refresh buffer if required
+{
+  if(refresh) read();
+  for(int i=0;i<7;i++)  // cycle through each component, create array of data
+  {
+	rtc[i]=get(i, 0);
+  }
+}
+
+
+byte DS1307::get(int c, boolean refresh)  // aquire individual RTC item from buffer, return as int, refresh buffer if required
+{
+  if(refresh) read();
+  byte v=-1;
+  switch(c)
+  {
+  case DS1307_SEC:
+    v=(10*((rtc_bcd[DS1307_SEC] & DS1307_HI_SEC)>>4))+(rtc_bcd[DS1307_SEC] & DS1307_LO_BCD);
+	break;
+  case DS1307_MIN:
+    v=(10*((rtc_bcd[DS1307_MIN] & DS1307_HI_MIN)>>4))+(rtc_bcd[DS1307_MIN] & DS1307_LO_BCD);
+	break;
+  case DS1307_HR:
+    v=(10*((rtc_bcd[DS1307_HR] & DS1307_HI_HR)>>4))+(rtc_bcd[DS1307_HR] & DS1307_LO_BCD);
+	break;
+  case DS1307_DOW:
+    v=rtc_bcd[DS1307_DOW] & DS1307_LO_DOW;
+	break;
+  case DS1307_DATE:
+    v=(10*((rtc_bcd[DS1307_DATE] & DS1307_HI_DATE)>>4))+(rtc_bcd[DS1307_DATE] & DS1307_LO_BCD);
+	break;
+  case DS1307_MTH:
+    v=(10*((rtc_bcd[DS1307_MTH] & DS1307_HI_MTH)>>4))+(rtc_bcd[DS1307_MTH] & DS1307_LO_BCD);
+	break;
+  case DS1307_YR:
+//    v=(10*((rtc_bcd[DS1307_YR] & DS1307_HI_YR)>>4))+(rtc_bcd[DS1307_YR] & DS1307_LO_BCD)+DS1307_BASE_YR;
+    v=(10*((rtc_bcd[DS1307_YR] & DS1307_HI_YR)>>4))+(rtc_bcd[DS1307_YR] & DS1307_LO_BCD);
+	break; 
+  } // end switch
+  return v;
+} 
+
+void DS1307::set(int c, int v)  // Update buffer, then update the chip
+{
+  switch(c)
+  {
+  case DS1307_SEC:
+    if(v<60 && v>-1)
+    {
+	//preserve existing clock state (running/stopped)
+	int state=rtc_bcd[DS1307_SEC] & DS1307_CLOCKHALT;
+	rtc_bcd[DS1307_SEC]=state | ((v / 10)<<4) + (v % 10);
+    }
+    break; 
+  case DS1307_MIN:
+    if(v<60 && v>-1)
+    {
+	rtc_bcd[DS1307_MIN]=((v / 10)<<4) + (v % 10);
+    }
+    break;
+  case DS1307_HR:
+  // TODO : AM/PM  12HR/24HR
+    if(v<24 && v>-1)
+    {
+	rtc_bcd[DS1307_HR]=((v / 10)<<4) + (v % 10);
+    }
+    break;
+  case DS1307_DOW: 
+    if(v<8 && v>-1)
+    {
+	rtc_bcd[DS1307_DOW]=v;
+    }
+    break;
+  case DS1307_DATE:
+    if(v<31 && v>-1)
+    {
+	rtc_bcd[DS1307_DATE]=((v / 10)<<4) + (v % 10);
+    }
+    break;
+  case DS1307_MTH:
+    if(v<13 && v>-1)
+    {
+	rtc_bcd[DS1307_MTH]=((v / 10)<<4) + (v % 10);
+    }
+    break;
+  case DS1307_YR:
+    if(v<13 && v>-1)
+    {
+	rtc_bcd[DS1307_YR]=((v / 10)<<4) + (v % 10);
+    }
+    break;
+  } // end switch
+  save();
+}
+
+void DS1307::stop(void)
+{
+	// set the ClockHalt bit high to stop the rtc
+	// this bit is part of the seconds byte
+    rtc_bcd[DS1307_SEC]=rtc_bcd[DS1307_SEC] | DS1307_CLOCKHALT;
+    save();
+}
+
+void DS1307::start(void)
+{
+	// unset the ClockHalt bit to start the rtc
+	// TODO : preserve existing seconds
+    rtc_bcd[DS1307_SEC]=0;
+	save();
+}
+
+
+
+ 

data/lib/libraries/DS1307/DS1307.h

@@ -0,0 +1,66 @@
+/*
+  DS1307.h - library for DS1307 rtc
+*/
+
+// ensure this library description is only included once
+#ifndef DS1307_h
+#define DS1307_h
+
+// include types & constants of Wiring core API
+#include <WConstants.h>
+
+// include types & constants of Wire ic2 lib
+#include <../Wire/Wire.h>
+
+#define DS1307_SEC 0
+#define DS1307_MIN 1
+#define DS1307_HR 2
+#define DS1307_DOW 3
+#define DS1307_DATE 4
+#define DS1307_MTH 5
+#define DS1307_YR 6
+#define DS1307_CTRL	7
+
+#define DS1307_BASE_YR 2000			// with change of get() return from int to byte. this is no longer 
+									// used, the user must add 2000 himself
+
+#define DS1307_CTRL_ID B1101000  	// DS1307
+
+ // Define register bit masks  
+#define DS1307_CLOCKHALT B10000000
+ 
+#define DS1307_LO_BCD  B00001111
+#define DS1307_HI_BCD  B11110000
+
+#define DS1307_HI_SEC  B01110000
+#define DS1307_HI_MIN  B01110000
+#define DS1307_HI_HR   B00110000
+#define DS1307_LO_DOW  B00000111
+#define DS1307_HI_DATE B00110000
+#define DS1307_HI_MTH  B00110000
+#define DS1307_HI_YR   B11110000
+
+// library interface description
+class DS1307
+{
+  // user-accessible "public" interface
+  public:
+    DS1307();
+    void get(byte*, boolean);
+    byte get(int, boolean);
+	void set(int, int);
+    void start(void);
+    void stop(void);
+
+  // library-accessible "private" interface
+  private:
+    byte rtc_bcd[7]; // used prior to read/set ds1307 registers;
+	void read(void);
+	void save(void);
+
+};
+
+extern DS1307 RTC;
+
+#endif
+ 

data/lib/libraries/DS1307/keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+DS1307	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+

data/lib/libraries/FrequencyTimer2/FrequencyTimer2.cpp

@@ -0,0 +1,144 @@
+
+
+
+#include <FrequencyTimer2.h>
+
+#include <avr/interrupt.h>
+
+void (*FrequencyTimer2::onOverflow)() = 0;
+uint8_t FrequencyTimer2::enabled = 0;
+
+#if defined(__AVR_ATmega168__)
+SIGNAL(SIG_OUTPUT_COMPARE2A)
+#else
+SIGNAL(SIG_OUTPUT_COMPARE2)
+#endif
+{
+    static uint8_t inHandler = 0; // protect us from recursion if our handler enables interrupts
+
+    if ( !inHandler && FrequencyTimer2::onOverflow) {
+	inHandler = 1;
+	(*FrequencyTimer2::onOverflow)();
+	inHandler = 0;
+    }
+}
+
+void FrequencyTimer2::setOnOverflow( void (*func)() )
+{
+    FrequencyTimer2::onOverflow = func;
+#if defined(__AVR_ATmega168__)
+    if ( func) TIMSK2 |= _BV(OCIE2A);
+    else TIMSK2 &= ~_BV(OCIE2A);
+#else
+    if ( func) TIMSK |= _BV(OCIE2);
+    else TIMSK &= ~_BV(OCIE2);
+#endif
+}
+
+void FrequencyTimer2::setPeriod(unsigned long period)
+{
+    uint8_t pre, top;
+  
+    if ( period == 0) period = 1;
+    period *= clockCyclesPerMicrosecond();
+ 
+    period /= 2;            // we work with half-cycles before the toggle 
+    if ( period <= 256) {
+	pre = 1;
+	top = period-1;
+    } else if ( period <= 256L*8) {
+	pre = 2;
+	top = period/8-1;
+    } else if ( period <= 256L*32) {
+	pre = 3;
+	top = period/32-1;
+    } else if ( period <= 256L*64) {
+	pre = 4;
+	top = period/64-1;
+    } else if ( period <= 256L*128) {
+	pre = 5;
+	top = period/128-1;
+    } else if ( period <= 256L*256) {
+	pre = 6;
+	top = period/256-1;
+    } else if ( period <= 256L*1024) {
+	pre = 7;
+	top = period/1024-1;
+    } else {
+	pre = 7;
+	top = 255;
+    }
+
+#if defined(__AVR_ATmega168__)
+    TCCR2B = 0;
+    TCCR2A = 0;
+    TCNT2 = 0;
+    ASSR &= ~_BV(AS2);    // use clock, not T2 pin
+    OCR2A = top;
+    TCCR2A = (_BV(WGM21) | ( FrequencyTimer2::enabled ? _BV(COM2A0) : 0));
+    TCCR2B = pre;
+#else
+    TCCR2 = 0;
+    TCNT2 = 0;
+    ASSR &= ~_BV(AS2);    // use clock, not T2 pin
+    OCR2 = top;
+    TCCR2 = (_BV(WGM21) | ( FrequencyTimer2::enabled ? _BV(COM20) : 0)  | pre);
+#endif
+}
+
+unsigned long  FrequencyTimer2::getPeriod()
+{
+#if defined(__AVR_ATmega168__)
+    uint8_t p = (TCCR2B & 7);
+    unsigned long v = OCR2A;
+#else
+    uint8_t p = (TCCR2 & 7);
+    unsigned long v = OCR2;
+#endif
+    uint8_t shift;
+  
+    switch(p) {
+      case 0 ... 1:
+	shift = 0;
+	break;
+      case 2:
+	shift = 3;
+	break;
+      case 3:
+	shift = 5;
+	break;
+      case 4:
+	shift = 6;
+	break;
+      case 5:
+	shift = 7;
+	break;
+      case 6:
+	shift = 8;
+	break;
+      case 7:
+	shift = 10;
+	break;
+    }
+    return (((v+1) << (shift+1)) + 1) / clockCyclesPerMicrosecond();   // shift+1 converts from half-period to period
+}
+
+void FrequencyTimer2::enable()
+{
+    FrequencyTimer2::enabled = 1;
+#if defined(__AVR_ATmega168__)
+    TCCR2A |= _BV(COM2A0);
+#else
+    TCCR2 |= _BV(COM20);
+#endif
+}
+
+void FrequencyTimer2::disable()
+{
+    FrequencyTimer2::enabled = 0;
+#if defined(__AVR_ATmega168__)
+    TCCR2A &= ~_BV(COM2A0);
+#else
+    TCCR2 &= ~_BV(COM20);
+#endif
+}

data/lib/libraries/FrequencyTimer2/FrequencyTimer2.h

@@ -0,0 +1,42 @@
+#ifndef FREQUENCYTIMER2_IS_IN
+#define FREQUENCYTIMER2_IS_IN
+
+/*
+  FrequencyTimer2.h - A frequency generator and interrupt generator library
+  Author: Jim Studt, jim@federated.com
+  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 <wiring.h>
+
+class FrequencyTimer2
+{
+  private:
+    static uint8_t enabled;
+  public:
+    static void (*onOverflow)(); // not really public, but I can't work out the 'friend' for the SIGNAL
+    
+  public:
+    static void setPeriod(unsigned long);
+    static unsigned long getPeriod();
+    static void setOnOverflow( void (*)() );
+    static void enable();
+    static void disable();
+};
+
+#endif

data/lib/libraries/FrequencyTimer2/keywords.txt

@@ -0,0 +1,22 @@
+#######################################
+# Syntax Coloring Map FrequencyTimer2
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+FrequencyTimer2  KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+setPeriod KEYWORD2
+getPeriod KEYWORD2
+enable KEYWORD2
+disable KEYWORD2
+setOnOverflow KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

data/lib/libraries/I2CEEPROM/I2CEEPROM.cpp

@@ -0,0 +1,120 @@
+/*************************************************************************************
+ *       Arduino Library Program Code for Serial I2C EEPROMS - I2CEEPROM.cpp
+ *  Adapted from an unsigned procedure on the Playground that had never been made
+ *  into a library. Adaptation by Brian Riley, Underhill Center, VT, USA
+ *                         <brianbr@wulfden.org> 
+ * ----------------------------------------------------------------------------------
+ *  Simple read & write to a 24LCxxx EEPROM using the Wire library. The library will
+ *  work with the 24LC16B (2KB), through and including 24LC512 (64KB). There is no way
+ *  to tell what chip is there and consequently what the ending address is. So
+ *  there is no address checking code, the programmer will have to keep track of his
+ *  address count in his own program code. A read of a non-existant location will 
+ *  return the value 0xFF, but there is no way to tell if its an 0xFF or a read
+ *  of non-existant memory
+ *
+ *  Functions for R/W of single byte or a page of bytes. Block/Page reads are 
+ *  limited to 28 bytes due to the Wire library buffer being 32 bytes.
+ *
+ *   Hardware Setup:
+ *                    _ _                                 
+ *   Arduino GND- A0-|oU |-Vcc  to Arduino Vcc
+ *   Arduino GND- A1-|   |-WP   to GND for now. Set to Vcc for write protection.
+ *   Arduino GND- A2-|   |-SCL  to Arduino 5
+ *   Arduino GND-Vss-|   |-SDA  to Arduino 4
+ *                    ---       (A2, A1, A0 to GND for 1010000 (0x50) address.)
+ *
+ *  Pulling any pin A2,A1,A0 to Vcc adds to base address 0x50, giving an address
+ *  range for 8 devices 0x50 through 0x57, The code below assumes the 0x50, so
+ *  when creating the instance one simply plugs in the relative address, a digit 
+ *  from 0 to 7. Now, the most common physical configuration is a single chip
+ *  at device address 0, so instantiating with no device address assumes a '0' 
+ *  which becomes address 0x50 .
+ *
+ ************************************************************************************/
+
+extern "C" {
+#include "WConstants.h"
+#include <../Wire/Wire.h>
+}
+#include "I2CEEPROM.h"
+
+/********************************
+ *  I2CEEPROM()  - constructors
+ ********************************/
+
+I2CEEPROM::I2CEEPROM() {
+  _device_address = 0x50;
+}
+
+I2CEEPROM::I2CEEPROM(int addr) {
+  _device_address = addr + 0x50;
+}
+
+/********************************
+ *  write_byte()
+ ********************************/
+
+void I2CEEPROM::write_byte( unsigned int eeaddress, byte data ) {
+  int rdata = data;
+  send_preamble(eeaddress);
+  Wire.send(rdata);
+  Wire.endTransmission();
+  delay(3);					// needed to sllow tiem for the write
+}
+
+/***************************************************************************
+ * write_page()
+ * Address is a page address, 6-bit (63). More and end will wrap
+ * around. But data can be maximum of 28 bytes, because the Wire library
+ * has a buffer of 32 bytes
+ ***************************************************************************/
+
+void I2CEEPROM::write_page( unsigned int eeaddresspage, byte* data, int length ) {
+  send_preamble(eeaddresspage);
+  for ( int c = 0; c < length; c++)
+    Wire.send(data[c]);
+  Wire.endTransmission();
+  delay(3*length);                           // need some delay
+}
+
+/********************************
+ *  read_byte()
+ ********************************/
+
+byte I2CEEPROM::read_byte( unsigned int eeaddress ) {
+  byte rdata = 0xFF;
+  send_preamble(eeaddress);
+  Wire.endTransmission();
+  Wire.requestFrom(_device_address,1);
+  if (Wire.available()) rdata = Wire.receive();
+  return rdata;
+}
+
+/************************************************
+ *  write_byte()
+ * should not read more than 28 bytes at a time!
+ ************************************************/
+ 
+void I2CEEPROM::read_buffer( unsigned int eeaddress, byte *buffer, int length ) {
+  send_preamble(eeaddress);
+  Wire.endTransmission();
+  Wire.requestFrom(_device_address,length);
+  for ( int c = 0; c < length; c++ )
+    if (Wire.available()) buffer[c] = Wire.receive();
+}
+
+
+/************************************************
+ *  send_preamble()
+ * private function - group repetitive stuff
+ ************************************************/
+
+void I2CEEPROM::send_preamble( unsigned int eeaddress ) {
+  Wire.beginTransmission(_device_address);
+  Wire.send((int)(eeaddress >> 8)); // Address High Byte
+  Wire.send((int)(eeaddress & 0xFF)); // Address Low Byte
+}
+
+
+
+ 

data/lib/libraries/I2CEEPROM/I2CEEPROM.h

@@ -0,0 +1,70 @@
+
+/*************************************************************************************
+ *       Arduino Library Header File for Serial I2C EEPROMS - I2CEEPROM.h
+ *  Adapted from an unsigned procedure on the Playground that had never been made
+ *  into a library. Adaptation by Brian Riley, Underhill Center, VT, USA
+ *                         <brianbr@wulfden.org> 
+ * ----------------------------------------------------------------------------------
+ *  Simple read & write to a 24LCxxx EEPROM using the Wire library. The library will
+ *  work with the 24LC16B (2KB), through and including 24LC512 (64KB). There is no way
+ *  to tell what chip is there and consequently what the ending address is. So
+ *  there is no address checking code, the programmer will have to keep track of his
+ *  address count in his own program code. A read of a non-existant location will 
+ *  return the value 0xFF, but there is no way to tell if its an 0xFF or a read
+ *  of non-existant memory
+ *
+ *  Functions for R/W of single byte or a page of bytes. Block/Page reads are 
+ *  limited to 28 bytes due to the Wire library buffer being 32 bytes.
+ *
+ *   Hardware Setup:
+ *                    _ _                                 
+ *   Arduino GND- A0-|oU |-Vcc  to Arduino Vcc
+ *   Arduino GND- A1-|   |-WP   to GND for now. Set to Vcc for write protection.
+ *   Arduino GND- A2-|   |-SCL  to Arduino 5
+ *   Arduino GND-Vss-|   |-SDA  to Arduino 4
+ *                    ---       (A2, A1, A0 to GND for 1010000 (0x50) address.)
+ *
+ *  Pulling any pin A2,A1,A0 to Vcc adds to base address 0x50, giving an address
+ *  range for 8 devices 0x50 through 0x57, The code below assumes the 0x50, so
+ *  when creating the instance one simply plugs in the relative address, a digit 
+ *  from 0 to 7. Now, the most common physical configuration is a single chip
+ *  at device address 0, so instantiating with no device address assumes a '0' 
+ *  which becomes address 0x50 .
+ *
+ ************************************************************************************/
+
+// ensure this library description is only included once
+#ifndef I2CEEPROM_h
+#define I2CEEPROM_h
+ 
+// include types & constants of Wiring core API
+#include <WConstants.h>
+
+// include types & constants of Wire i2c lib
+#include <../Wire/Wire.h>
+
+// library interface description
+class I2CEEPROM
+{
+  // user-accessible "public" interface
+  public:
+    I2CEEPROM();
+    I2CEEPROM(int);
+
+	void write_byte( unsigned int, byte );
+
+	void write_page( unsigned int, byte*, int );
+
+	byte read_byte( unsigned int );
+
+	void read_buffer( unsigned int, byte*, int );
+
+  // library-accessible "private" interface
+  private:
+    int _device_address;
+	void send_preamble(unsigned int);
+};
+
+
+#endif
+ 

data/lib/libraries/I2CEEPROM/keywords.txt

@@ -0,0 +1,21 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+I2CEEPROM	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+read_byte	KEYWORD2
+write_byte	KEYWORD2
+read_buffer	KEYWORD2
+write_page	KEYWORD2
+#######################################
+# Constants (LITERAL1)
+#######################################
+

data/lib/libraries/LoopTimer/LoopTimer.cpp

@@ -0,0 +1,35 @@
+/*
+  LoopTime.cpp - - Loop Timer library for Wiring/Arduino - Version 0.1
+  
+  Original code by JD Banrhart
+  Original Arduino Library by BB Riley
+
+*/
+
+
+// include types & constants of Wiring core API
+#include "WProgram.h"
+#include "LoopTimer.h"
+
+LoopTimer::LoopTimer()
+{
+	start_loop_time = 0;
+	total_loop_time = 0;	
+}	
+    
+// track method
+void LoopTimer::track(void)
+{
+	total_loop_time = millis() - start_loop_time;
+	start_loop_time = millis();	
+}
+
+// get total loop time:
+unsigned long LoopTimer::get_total(void)
+{
+	return total_loop_time;
+}
+
+
+	
+