rad 0.2.2 → 0.2.9

data/lib/libraries/AF_XPort/AF_XPort.h

@@ -0,0 +1,48 @@
+
+#ifndef _AFXPort_h_
+#define _AFXPort_h_
+
+
+#define ERROR_NONE 0
+#define ERROR_TIMEDOUT 2
+#define ERROR_BADRESP 3
+#define ERROR_DISCONN 4
+
+#include <avr/pgmspace.h>
+
+
+class AF_XPort
+{
+ private:
+ 
+  uint8_t rxpin, txpin, resetpin, dtrpin, rtspin, ctspin;
+ public:
+  AF_XPort(uint8_t rx, uint8_t tx, uint8_t reset=0, uint8_t dtr=0, uint8_t rts=0, uint8_t cts=0);
+  void begin(uint16_t b);
+  uint8_t reset(void);
+  uint8_t serialavail_timeout(int timeout);
+  uint8_t readline_timeout(char *buff, uint8_t maxlen, int timeout);
+  void flush(int timeout);
+  void disconnect();
+  uint8_t connect(char *ipaddr, long port);
+  void ROM_print(const char *pSTR);
+  uint8_t disconnected();
+
+  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 println(void);
+    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/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/{SWSerLCDpa → DS1307}/keywords.txt

@@ -6,7 +6,7 @@
 # Datatypes (KEYWORD1)
 #######################################
 
-SoftwareSerial	KEYWORD1
+DS1307	KEYWORD1
 
 #######################################
 # Methods and Functions (KEYWORD2)

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