pax_global_header00006660000000000000000000000064120162716470014520gustar00rootroot0000000000000052 comment=0c731816ff2f0115d7e9fbf1212874cfae2fb86b MCP79412RTC-0.9/000077500000000000000000000000001201627164700127675ustar00rootroot00000000000000MCP79412RTC-0.9/Examples/000077500000000000000000000000001201627164700145455ustar00rootroot00000000000000MCP79412RTC-0.9/Examples/PowerOutageLogger/000077500000000000000000000000001201627164700201465ustar00rootroot00000000000000MCP79412RTC-0.9/Examples/PowerOutageLogger/PowerOutageLogger.ino000066400000000000000000000173171201627164700242670ustar00rootroot00000000000000/*----------------------------------------------------------------------* * Power Outage Logger using Microchip MCP79412 RTC. * * Assumes the RTC is running and set to UTC. * * A maximum of 7 outages (power down/up times) can be logged in the * * RTC's SRAM. * * * * Jack Christensen 23Aug2012 * * * * This work is licensed under the Creative Commons Attribution- * * ShareAlike 3.0 Unported License. To view a copy of this license, * * visit http://creativecommons.org/licenses/by-sa/3.0/ or send a * * letter to Creative Commons, 171 Second Street, Suite 300, * * San Francisco, California, 94105, USA. * *----------------------------------------------------------------------*/ #include //http://github.com/JChristensen/MCP79412RTC #include //http://arduiniana.org/libraries/streaming/ #include //http://www.arduino.cc/playground/Code/Time #include //http://github.com/JChristensen/Timezone #include //http://arduino.cc/en/Reference/Wire (included with Arduino IDE) #define FIRST_OUTAGE_ADDR 0x08 //address of first outage timestamps in RTC SRAM #define OUTAGE_LENGTH 8 //8 data bytes for each outage (start and end timestamps, both are time_t values) #define MAX_OUTAGES 7 //maximum number of outage timestamp pairs that can be stored in SRAM #define MAX_OUTAGE_ADDR FIRST_OUTAGE_ADDR + OUTAGE_LENGTH * (MAX_OUTAGES - 1) //last outage address #define APP_ID 1 //APP_ID and 4 bytes of the RTC ID are stored in sram to provide //a way to recognize that the logging data structure has been initialized #define RTC_ID_LO 0x00 //lower 4 bytes of RTC unique ID are stored at sram addr 0x00 #define APP_ID_ADDR 0x04 //address of appID (1) #define NBR_OUTAGES_ADDR 0x05 //address containing number of outages currently stored in SRAM #define NEXT_OUTAGE_ADDR 0x06 //address containing pointer to next outage #define RFU_ADDR 0x07 //reserved for future use //US Eastern Time Zone (New York, Detroit) TimeChangeRule myDST = {"EDT", Second, Sun, Mar, 2, -240}; //Daylight time = UTC - 4 hours TimeChangeRule mySTD = {"EST", First, Sun, Nov, 2, -300}; //Standard time = UTC - 5 hours Timezone myTZ(myDST, mySTD); TimeChangeRule *tcr; //pointer to the time change rule, used to get TZ abbrev time_t utc, local, lastUTC; void setup() { Serial.begin(115200); setSyncProvider(RTC.get); //the function to get the time from the RTC Serial << "RTC SYNC"; if (timeStatus()!= timeSet) Serial << "FAIL"; Serial << endl; //logClear(); logOutage(); } void loop() { //nothing here in loop() has anything to do with logging power outages, //we just print the time every second so that something is happening. utc = now(); if (utc != lastUTC) { lastUTC = utc; local = myTZ.toLocal(utc, &tcr); Serial << endl; printTime(utc, "UTC"); printTime(local, tcr -> abbrev); } } //initialize the log data structure in the RTC SRAM if needed. //log a new outage if one occurred. //print out the outages logged. void logOutage(void) { union { uint8_t b[8]; struct { uint32_t hi; uint32_t lo; }; } uniqueID; //8-byte RTC "unique ID" with access to upper and lower halves uint32_t loID; //lower half of the unique ID read from sram uint8_t appID; //app ID read from sram uint8_t nOutage; //number of outages stored in sram uint8_t nextOutage; //address of next outage timestamps in sram uint8_t outageAddr; //outage address in sram time_t powerDown, powerUp; //power outage timestamps RTC.idRead(uniqueID.b); //get the RTC's ID loID = read32(RTC_ID_LO); //if already initialized, the lower half of the ID is stored at SRAM addr 0x00, appID = RTC.sramRead(APP_ID_ADDR); //and the app ID (1) is at addr 0x04. Serial << "RTC ID"; for (uint8_t i=0; i<8; i++) { Serial << (uniqueID.b[i] < 16 ? " 0" : " ") << _HEX(uniqueID.b[i]); } if ( loID != uniqueID.lo || appID != 1 ) { //logging initialized? write32(RTC_ID_LO, uniqueID.lo); //least significant half of the RTC unique ID RTC.sramWrite(APP_ID_ADDR, APP_ID); //app ID RTC.sramWrite(NBR_OUTAGES_ADDR, 0); //number of outages RTC.sramWrite(NEXT_OUTAGE_ADDR, FIRST_OUTAGE_ADDR); //next location for outage times RTC.sramWrite(RFU_ADDR, 0); //reserved for future use Serial << "Logging initialized" << endl; //no, do it now } //if an outage has occurred, record it if ( RTC.powerFail(&powerDown, &powerUp) ) { nOutage = RTC.sramRead(NBR_OUTAGES_ADDR); nextOutage = RTC.sramRead(NEXT_OUTAGE_ADDR); write32(nextOutage, powerDown); write32(nextOutage + 4, powerUp); nextOutage += OUTAGE_LENGTH; if (nextOutage > MAX_OUTAGE_ADDR) nextOutage = FIRST_OUTAGE_ADDR; RTC.sramWrite(NEXT_OUTAGE_ADDR, nextOutage); if (nOutage < MAX_OUTAGES) RTC.sramWrite(NBR_OUTAGES_ADDR, ++nOutage); } //print out all the outages logged nOutage = RTC.sramRead(NBR_OUTAGES_ADDR); nextOutage = RTC.sramRead(NEXT_OUTAGE_ADDR); outageAddr = nextOutage - OUTAGE_LENGTH; if (outageAddr < FIRST_OUTAGE_ADDR) outageAddr = MAX_OUTAGE_ADDR; Serial << endl << endl << "Power outages logged: " << _DEC(nOutage) << endl; for (uint8_t i=nOutage; i>0; i--) { powerDown = read32(outageAddr); powerUp = read32(outageAddr + 4); Serial << endl << _DEC(i) << ": Power down "; printTime(myTZ.toLocal(powerDown, &tcr), tcr -> abbrev); Serial << _DEC(i) << ": Power up "; printTime(myTZ.toLocal(powerUp, &tcr), tcr -> abbrev); outageAddr -= OUTAGE_LENGTH; if (outageAddr < FIRST_OUTAGE_ADDR) outageAddr = MAX_OUTAGE_ADDR; } } //destroy the logging data structure and log data void logClear(void) { for (uint8_t i=0; i #include #include //http://github.com/JChristensen/MCP79412RTC void setup() { Serial.begin(9600); setSyncProvider(RTC.get); // the function to get the time from the RTC if(timeStatus()!= timeSet) Serial.println("Unable to sync with the RTC"); else Serial.println("RTC has set the system time"); } void loop() { digitalClockDisplay(); delay(1000); } void digitalClockDisplay(){ // digital clock display of the time Serial.print(hour()); printDigits(minute()); printDigits(second()); Serial.print(" "); Serial.print(day()); Serial.print(" "); Serial.print(month()); Serial.print(" "); Serial.print(year()); Serial.println(); } void printDigits(int digits){ // utility function for digital clock display: prints preceding colon and leading 0 Serial.print(":"); if(digits < 10) Serial.print('0'); Serial.print(digits); } MCP79412RTC-0.9/MCP79412RTC.cpp000066400000000000000000000605021201627164700150750ustar00rootroot00000000000000/*----------------------------------------------------------------------* * MCP79412RTC.cpp - Arduino library for the Microchip MCP79412 * * Real-Time Clock. This library is intended for use with the Arduino * * Time.h library, http://www.arduino.cc/playground/Code/Time * * * * This library is a drop-in replacement for the DS1307RTC.h library * * by Michael Margolis that is supplied with the Arduino Time library * * above. To change from using a DS1307 RTC to an MCP79412 RTC, it is * * only necessary to change the #include statement to include this * * library instead of DS1307RTC.h. * * * * In addition, this library implements functions to support the * * additional features of the MCP79412. * * * * Jack Christensen 29Jul2012 * * * * This work is licensed under the Creative Commons Attribution- * * ShareAlike 3.0 Unported License. To view a copy of this license, * * visit http://creativecommons.org/licenses/by-sa/3.0/ or send a * * letter to Creative Commons, 171 Second Street, Suite 300, * * San Francisco, California, 94105, USA. * *----------------------------------------------------------------------*/ #include #include "MCP79412RTC.h" /*----------------------------------------------------------------------* * Constructor. * *----------------------------------------------------------------------*/ MCP79412RTC::MCP79412RTC() { Wire.begin(); } /*----------------------------------------------------------------------* * Read the current time from the RTC and return it as a time_t value. * *----------------------------------------------------------------------*/ time_t MCP79412RTC::get() { tmElements_t tm; read(tm); return(makeTime(tm)); } /*----------------------------------------------------------------------* * Set the RTC to the given time_t value. * *----------------------------------------------------------------------*/ void MCP79412RTC::set(time_t t) { tmElements_t tm; breakTime(t, tm); write(tm); } /*----------------------------------------------------------------------* * Read the current time from the RTC and return it in a tmElements_t * * structure. * *----------------------------------------------------------------------*/ void MCP79412RTC::read(tmElements_t &tm) { Wire.beginTransmission(RTC_ADDR); i2cWrite(TIME_REG); Wire.endTransmission(); //request 7 bytes (secs, min, hr, dow, date, mth, yr) Wire.requestFrom(RTC_ADDR, tmNbrFields); tm.Second = bcd2dec(i2cRead() & ~_BV(ST)); tm.Minute = bcd2dec(i2cRead()); tm.Hour = bcd2dec(i2cRead() & ~_BV(HR1224)); //assumes 24hr clock tm.Wday = i2cRead() & ~(_BV(OSCON) | _BV(VBAT) | _BV(VBATEN)); //mask off OSCON, VBAT, VBATEN bits tm.Day = bcd2dec(i2cRead()); tm.Month = bcd2dec(i2cRead() & ~_BV(LP)); //mask off the leap year bit tm.Year = y2kYearToTm(bcd2dec(i2cRead())); } /*----------------------------------------------------------------------* * Set the RTC's time from a tmElements_t structure. * *----------------------------------------------------------------------*/ void MCP79412RTC::write(tmElements_t &tm) { Wire.beginTransmission(RTC_ADDR); i2cWrite(TIME_REG); i2cWrite(0x00); //stops the oscillator (Bit 7, ST == 0) i2cWrite(dec2bcd(tm.Minute)); i2cWrite(dec2bcd(tm.Hour)); //sets 24 hour format (Bit 6 == 0) i2cWrite(tm.Wday | _BV(VBATEN)); //enable battery backup operation i2cWrite(dec2bcd(tm.Day)); i2cWrite(dec2bcd(tm.Month)); i2cWrite(dec2bcd(tmYearToY2k(tm.Year))); Wire.endTransmission(); Wire.beginTransmission(RTC_ADDR); i2cWrite(TIME_REG); i2cWrite(dec2bcd(tm.Second) | _BV(ST)); //set the seconds and start the oscillator (Bit 7, ST == 1) Wire.endTransmission(); } /*----------------------------------------------------------------------* * Write a single byte to RTC RAM. * * Valid address range is 0x00 - 0x5F, no checking. * *----------------------------------------------------------------------*/ void MCP79412RTC::ramWrite(byte addr, byte value) { ramWrite(addr, &value, 1); } /*----------------------------------------------------------------------* * Write multiple bytes to RTC RAM. * * Valid address range is 0x00 - 0x5F, no checking. * * Number of bytes (nBytes) must be between 1 and 31 (Wire library * * has a limitation of 31 bytes). * *----------------------------------------------------------------------*/ void MCP79412RTC::ramWrite(byte addr, byte *values, byte nBytes) { Wire.beginTransmission(RTC_ADDR); i2cWrite(addr); for (byte i=0; i= 1 && nBytes <= I2C_BYTE_LIMIT && (addr + nBytes) <= SRAM_SIZE) { ramWrite( (addr & (SRAM_SIZE - 1) ) + SRAM_START_ADDR, values, nBytes ); } } /*----------------------------------------------------------------------* * Read a single byte from Static RAM. * * Address (addr) is constrained to the range (0, 63). * *----------------------------------------------------------------------*/ byte MCP79412RTC::sramRead(byte addr) { byte value; ramRead( (addr & (SRAM_SIZE - 1) ) + SRAM_START_ADDR, &value, 1 ); return value; } /*----------------------------------------------------------------------* * Read multiple bytes from Static RAM. * * Address (addr) is constrained to the range (0, 63). * * Number of bytes (nBytes) must be between 1 and 31 (Wire library * * has a limitation of 31 bytes). * * Invalid values for addr or nBytes, or combinations of addr and * * nBytes that would result in addressing past the last byte of SRAM * * result in no action. * *----------------------------------------------------------------------*/ void MCP79412RTC::sramRead(byte addr, byte *values, byte nBytes) { if (nBytes >= 1 && nBytes <= I2C_BYTE_LIMIT && (addr + nBytes) <= SRAM_SIZE) { ramRead((addr & (SRAM_SIZE - 1) ) + SRAM_START_ADDR, values, nBytes); } } /*----------------------------------------------------------------------* * Write a single byte to EEPROM. * * Address (addr) is constrained to the range (0, 127). * * Can't leverage page write function because a write can't start * * mid-page. * *----------------------------------------------------------------------*/ void MCP79412RTC::eepromWrite(byte addr, byte value) { Wire.beginTransmission(EEPROM_ADDR); i2cWrite( addr & (EEPROM_SIZE - 1) ); i2cWrite(value); Wire.endTransmission(); eepromWait(); } /*----------------------------------------------------------------------* * Write a page (or less) to EEPROM. An EEPROM page is 8 bytes. * * Address (addr) should be a page start address (0, 8, ..., 120), but * * is ruthlessly coerced into a valid value. * * Number of bytes (nBytes) must be between 1 and 8, other values * * result in no action. * *----------------------------------------------------------------------*/ void MCP79412RTC::eepromWrite(byte addr, byte *values, byte nBytes) { if (nBytes >= 1 && nBytes <= EEPROM_PAGE_SIZE) { Wire.beginTransmission(EEPROM_ADDR); i2cWrite( addr & ~(EEPROM_PAGE_SIZE - 1) & (EEPROM_SIZE - 1) ); for (byte i=0; i= 1 && nBytes <= I2C_BYTE_LIMIT && (addr + nBytes) <= EEPROM_SIZE) { Wire.beginTransmission(EEPROM_ADDR); i2cWrite( addr & (EEPROM_SIZE - 1) ); Wire.endTransmission(); Wire.requestFrom( (uint8_t)EEPROM_ADDR, nBytes ); for (byte i=0; i= -127 && value <= 127) { calibVal = abs(value); if (value < 0) calibVal += 128; ramWrite(CALIB_REG, calibVal); } } /*----------------------------------------------------------------------* * Read the unique ID. * * Caller must provide an 8-byte array to contain the results. * *----------------------------------------------------------------------*/ void MCP79412RTC::idRead(byte *uniqueID) { Wire.beginTransmission(EEPROM_ADDR); i2cWrite(UNIQUE_ID_ADDR); Wire.endTransmission(); Wire.requestFrom( EEPROM_ADDR, UNIQUE_ID_SIZE ); for (byte i=0; i *powerUp) { --dn.Year; *powerDown = makeTime(dn); } } else return false; } /*----------------------------------------------------------------------* * Enable or disable the square wave output. * *----------------------------------------------------------------------*/ void MCP79412RTC::squareWave(uint8_t freq) { uint8_t ctrlReg; ramRead(CTRL_REG, &ctrlReg, 1); if (freq > 3) { ctrlReg &= ~_BV(SQWE); } else { ctrlReg = (ctrlReg & 0xF8) | _BV(SQWE) | freq; } ramWrite(CTRL_REG, &ctrlReg, 1); } /*----------------------------------------------------------------------* * Set an alarm time. Sets the alarm registers only, does not enable * * the alarm. See enableAlarm(). * *----------------------------------------------------------------------*/ void MCP79412RTC::setAlarm(uint8_t alarmNumber, time_t alarmTime) { tmElements_t tm; uint8_t day; //need to preserve bits in the day (of week) register alarmNumber &= 0x01; //ensure a valid alarm number ramRead( ALM0_DAY + alarmNumber * (ALM1_REG - ALM0_REG) , &day, 1); breakTime(alarmTime, tm); Wire.beginTransmission(RTC_ADDR); i2cWrite( ALM0_REG + alarmNumber * (ALM1_REG - ALM0_REG) ); i2cWrite(dec2bcd(tm.Second)); i2cWrite(dec2bcd(tm.Minute)); i2cWrite(dec2bcd(tm.Hour)); //sets 24 hour format (Bit 6 == 0) i2cWrite( (day & 0xF8) + tm.Wday ); i2cWrite(dec2bcd(tm.Day)); i2cWrite(dec2bcd(tm.Month)); Wire.endTransmission(); } /*----------------------------------------------------------------------* * Enable or disable an alarm, and set the trigger criteria, * * e.g. match only seconds, only minutes, entire time and date, etc. * *----------------------------------------------------------------------*/ void MCP79412RTC::enableAlarm(uint8_t alarmNumber, uint8_t alarmType) { uint8_t day; //alarm day register has config & flag bits uint8_t ctrl; //control register has alarm enable bits alarmNumber &= 0x01; //ensure a valid alarm number ramRead(CTRL_REG, &ctrl, 1); if (alarmType < ALM_DISABLE) { ramRead(ALM0_DAY + alarmNumber * (ALM1_REG - ALM0_REG), &day, 1); day = ( day & 0x87 ) | alarmType << 4; //reset interrupt flag, OR in the config bits ramWrite(ALM0_DAY + alarmNumber * (ALM1_REG - ALM0_REG), &day, 1); ctrl |= _BV(ALM0 + alarmNumber); //enable the alarm } else { ctrl &= ~(_BV(ALM0 + alarmNumber)); //disable the alarm } ramWrite(CTRL_REG, &ctrl, 1); } /*----------------------------------------------------------------------* * Returns true or false depending on whether the given alarm has been * * triggered, and resets the alarm "interrupt" flag. This is not a real * * interrupt, just a bit that's set when an alarm is triggered. * *----------------------------------------------------------------------*/ boolean MCP79412RTC::alarm(uint8_t alarmNumber) { uint8_t day; //alarm day register has config & flag bits alarmNumber &= 0x01; //ensure a valid alarm number ramRead( ALM0_DAY + alarmNumber * (ALM1_REG - ALM0_REG), &day, 1); if (day & _BV(ALMIF)) { day &= ~_BV(ALMIF); //turn off the alarm "interrupt" flag ramWrite( ALM0_DAY + alarmNumber * (ALM1_REG - ALM0_REG), &day, 1); return true; } else return false; } /*----------------------------------------------------------------------* * Sets the logic level on the MFP when it's not being used as a * * square wave or alarm output. The default is HIGH. * *----------------------------------------------------------------------*/ void MCP79412RTC::out(boolean level) { uint8_t ctrlReg; ramRead(CTRL_REG, &ctrlReg, 1); if (level) ctrlReg |= _BV(OUT); else ctrlReg &= ~_BV(OUT); ramWrite(CTRL_REG, &ctrlReg, 1); } /*----------------------------------------------------------------------* * Specifies the logic level on the Multi-Function Pin (MFP) when an * * alarm is triggered. The default is HIGH. When both alarms are * * active, the two are ORed together to determine the level of the MFP. * * With alarm polarity set to LOW (the default), this causes the MFP * * to go low only when BOTH alarms are triggered. With alarm polarity * * set to HIGH, the MFP will go high when EITHER alarm is triggered. * * * * Note that the state of the MFP is independent of the alarm * * "interrupt" flags, and the alarm() function will indicate when an * * alarm is triggered regardless of the polarity. * *----------------------------------------------------------------------*/ void MCP79412RTC::alarmPolarity(boolean polarity) { uint8_t alm0Day; ramRead(ALM0_DAY, &alm0Day, 1); if (polarity) alm0Day |= _BV(OUT); else alm0Day &= ~_BV(OUT); ramWrite(ALM0_DAY, &alm0Day, 1); } /*----------------------------------------------------------------------* * Check to see if the RTC's oscillator is started (ST bit in seconds * * register). Returns true if started. * *----------------------------------------------------------------------*/ boolean MCP79412RTC::oscStarted(void) { Wire.beginTransmission(RTC_ADDR); i2cWrite(TIME_REG); Wire.endTransmission(); //request just the seconds register Wire.requestFrom(RTC_ADDR, 1); return i2cRead() & _BV(ST); } /*----------------------------------------------------------------------* * Decimal-to-BCD conversion * *----------------------------------------------------------------------*/ uint8_t MCP79412RTC::dec2bcd(uint8_t num) { return ((num / 10 * 16) + (num % 10)); } /*----------------------------------------------------------------------* * BCD-to-Decimal conversion * *----------------------------------------------------------------------*/ uint8_t MCP79412RTC::bcd2dec(uint8_t num) { return ((num / 16 * 10) + (num % 16)); } MCP79412RTC RTC = MCP79412RTC(); //instantiate an RTC object MCP79412RTC-0.9/MCP79412RTC.h000066400000000000000000000154641201627164700145510ustar00rootroot00000000000000/*----------------------------------------------------------------------* * MCP79412RTC.h - Arduino library for the Microchip MCP79412 * * Real-Time Clock. This library is intended for use with the Arduino * * Time.h library, http://www.arduino.cc/playground/Code/Time * * * * This library is a drop-in replacement for the DS1307RTC.h library * * by Michael Margolis that is supplied with the Arduino Time library * * above. To change from using a DS1307 RTC to an MCP79412 RTC, it is * * only necessary to change the #include statement to include this * * library instead of DS1307RTC.h. * * * * In addition, this library implements functions to support the * * additional features of the MCP79412. * * * * Jack Christensen 29Jul2012 * * * * This work is licensed under the Creative Commons Attribution- * * ShareAlike 3.0 Unported License. To view a copy of this license, * * visit http://creativecommons.org/licenses/by-sa/3.0/ or send a * * letter to Creative Commons, 171 Second Street, Suite 300, * * San Francisco, California, 94105, USA. * *----------------------------------------------------------------------*/ #ifndef MCP79412RTC_h #define MCP79412RTC_h #include #if defined(ARDUINO) && ARDUINO >= 100 #include #else #include #endif //define release-independent I2C functions #if ARDUINO >= 100 #define i2cRead Wire.read #define i2cWrite Wire.write #else #define i2cRead Wire.receive #define i2cWrite Wire.send #endif //MCP7941x I2C Addresses #define RTC_ADDR 0x6F #define EEPROM_ADDR 0x57 //MCP7941x Register Addresses #define TIME_REG 0x00 //7 registers, Seconds, Minutes, Hours, DOW, Date, Month, Year #define DAY_REG 0x03 //the RTC Day register contains the OSCON, VBAT, and VBATEN bits #define YEAR_REG 0x06 //RTC year register #define CTRL_REG 0x07 //control register #define CALIB_REG 0x08 //calibration register #define UNLOCK_ID_REG 0x09 //unlock ID register #define ALM0_REG 0x0A //alarm 0, 6 registers, Seconds, Minutes, Hours, DOW, Date, Month #define ALM1_REG 0x11 //alarm 1, 6 registers, Seconds, Minutes, Hours, DOW, Date, Month #define ALM0_DAY 0x0D //DOW register has alarm config/flag bits #define PWRDWN_TS_REG 0x18 //power-down timestamp, 4 registers, Minutes, Hours, Date, Month #define PWRUP_TS_REG 0x1C //power-up timestamp, 4 registers, Minutes, Hours, Date, Month #define TIMESTAMP_SIZE 8 //number of bytes in the two timestamp registers #define SRAM_START_ADDR 0x20 //first SRAM address #define SRAM_SIZE 64 //number of bytes of SRAM #define EEPROM_SIZE 128 //number of bytes of EEPROM #define EEPROM_PAGE_SIZE 8 //number of bytes on an EEPROM page #define I2C_BYTE_LIMIT 31 //Wire library limitation, only 31 data bytes can be transferred. #define UNIQUE_ID_ADDR 0xF0 //starting address for unique ID #define UNIQUE_ID_SIZE 8 //number of bytes in unique ID //Control Register bits #define OUT 7 //sets logic level on MFP when not used as square wave output #define SQWE 6 //set to enable square wave output #define ALM1 5 //alarm 1 is active #define ALM0 4 //alarm 0 is active #define EXTOSC 3 //set to drive the RTC registers from an external oscillator instead of a crystal #define RS2 2 //RS2:0 set square wave output frequency: 0==1Hz, 1==4096Hz, 2==8192Hz, 3=32768Hz #define RS1 1 #define RS0 0 enum {SQWAVE_1_HZ, SQWAVE_4096_HZ, SQWAVE_8192_HZ, SQWAVE_32768_HZ, SQWAVE_NONE}; //Other Control Bits #define ST 7 //Seconds register (TIME_REG) oscillator start/stop bit, 1==Start, 0==Stop #define HR1224 6 //Hours register (TIME_REG+2) 12 or 24 hour mode (24 hour mode==0) #define AMPM 5 //Hours register (TIME_REG+2) AM/PM bit for 12 hour mode #define OSCON 5 //Day register (TIME_REG+3) oscillator running (set and cleared by hardware) #define VBAT 4 //Day register (TIME_REG+3) set by hardware when Vcc fails and RTC runs on battery. //VBAT is cleared by software, clearing VBAT also clears the timestamp registers #define VBATEN 3 //Day register (TIME_REG+3) VBATEN==1 enables backup battery, VBATEN==0 disconnects the VBAT pin (e.g. to save battery) #define LP 5 //Month register (TIME_REG+5) leap year bit //Alarm Control Bits #define ALMPOL 7 //Alarm Polarity: Defines the logic level for the MFP when an alarm is triggered. #define ALMC2 6 //Alarm configuration bits determine how alarms match. See ALM_MATCH defines below. #define ALMC1 5 #define ALMC0 4 #define ALMIF 3 //Alarm Interrupt Flag: Set by hardware when an alarm was triggered, cleared by software. enum {ALM_MATCH_SECONDS, ALM_MATCH_MINUTES, ALM_MATCH_HOURS, ALM_MATCH_DAY, ALM_MATCH_DATE, ALM_RESERVED_5, ALM_RESERVED_6, ALM_MATCH_DATETIME, ALM_DISABLE}; //Note ALM_MATCH_DAY triggers alarm at midnight #define ALARM_0 0 //constants for calling functions #define ALARM_1 1 class MCP79412RTC { public: MCP79412RTC(); static time_t get(void); static void set(time_t t); static void read(tmElements_t &tm); static void write(tmElements_t &tm); void sramWrite(byte addr, byte value); void sramWrite(byte addr, byte *values, byte nBytes); byte sramRead(byte addr); void sramRead(byte addr, byte *values, byte nBytes); void eepromWrite(byte addr, byte value); void eepromWrite(byte addr, byte *values, byte nBytes); byte eepromRead(byte addr); void eepromRead(byte addr, byte *values, byte nBytes); int calibRead(void); void calibWrite(int value); void idRead(byte *uniqueID); boolean powerFail(time_t *powerDown, time_t *powerUp); void squareWave(uint8_t freq); void setAlarm(uint8_t alarmNumber, time_t alarmTime); void enableAlarm(uint8_t alarmNumber, uint8_t alarmType); boolean alarm(uint8_t alarmNumber); void out(boolean level); void alarmPolarity(boolean polarity); boolean oscStarted(void); private: static void ramWrite(byte addr, byte value); static void ramWrite(byte addr, byte *values, byte nBytes); static byte ramRead(byte addr); static void ramRead(byte addr, byte *values, byte nBytes); static byte eepromWait(void); static uint8_t dec2bcd(uint8_t num); static uint8_t bcd2dec(uint8_t num); }; extern MCP79412RTC RTC; #endif MCP79412RTC-0.9/ReadMe.txt000066400000000000000000000135251201627164700146730ustar00rootroot00000000000000/*----------------------------------------------------------------------* * MCP79412RTC.cpp - Arduino library to support the Microchip MCP79412 * * Real-Time Clock. This library is intended for use with the Arduino * * Time.h library, http://www.arduino.cc/playground/Code/Time * * * * This library is a drop-in replacement for the DS1307RTC.h library * * by Michael Margolis that is supplied with the Arduino Time library * * above. To change from using a DS1307 RTC to an MCP79412 RTC, it is * * only necessary to change the #include statement to include * * MCP79412RTC.h instead of DS1307RTC.h. * * * * In addition, this library implements functions to support the * * additional features of the MCP79412. * * * * Jack Christensen 29Jul2012 * * * * This work is licensed under the Creative Commons Attribution- * * ShareAlike 3.0 Unported License. To view a copy of this license, * * visit http://creativecommons.org/licenses/by-sa/3.0/ or send a * * letter to Creative Commons, 171 Second Street, Suite 300, * * San Francisco, California, 94105, USA. * *----------------------------------------------------------------------*/ Alpha Version 0.9 Aug-2012 Currently implemented: Functions to set and read the time from the RTC. Functions to read and write SRAM and EEPROM. Functions to read and write the calibration register and to read the 64-bit ID. Alarm functions: Set, enable, detect. Functions to read and reset the power fail timestamps. Function(s) to enable and set the CLKOUT frequency. Function to set the MFP logic level when not used as a square wave output. Function to set alarm polarity. Not yet implemented: Decent documentation. Example sketches. Brief descriptions of currently implemented functions follow. time_t get(void); Read the current time from the RTC and return as a time_t value. void set(time_t t); Set the RTC to the given time_t value. read(tmElements_t &tm); Read the current time from the RTC and return as a tmElements_t structure. See the Arduino Time library for details on the tmElements_t structure: http://www.arduino.cc/playground/Code/Time. void write(tmElements_t &tm); Set the RTC to the time represented in the given tmElements_t structure. void sramWrite(byte addr, byte value); Write a single byte to the RTC static RAM. void sramWrite(byte addr, byte *values, byte nBytes); Write multiple bytes to the RTC static RAM. nBytes <= 31. values is a byte array, e.g. byte myValues[31]; byte sramRead(byte addr); Read a single byte from the RTC static RAM. void sramRead(byte addr, byte *values, byte nBytes); Read multiple bytes from the RTC static RAM, place their values into the given array. nBytes <= 31. void eepromWrite(byte addr, byte value); Write a single byte to the RTC EEPROM. void eepromWrite(byte addr, byte *values, byte nBytes); Write multiple bytes to the RTC EEPROM. nBytes <= 31. values is a byte array, e.g. byte myValues[31]; byte eepromRead(byte addr); Read a single byte from the RTC EEPROM. void eepromRead(byte addr, byte *values, byte nBytes); Read multiple bytes from the RTC static RAM, place their values into the given array. nBytes <= 31. int calibRead(void); Returns the value of the RTC calibration register. This is an adjustment factor in PPM, and must be between -127 and 127. void calibWrite(int value); Write the given value into the RTC calibration register. void idRead(byte *uniqueID); Read the 64-bit unique ID from the RTC into the given 8-byte array. boolean powerFail(time_t *powerDown, time_t *powerUp); Returns true or false to indicate whether a power failure has occurred. If one occurred, the power down and power up timestamps are returned in the variables given by the caller, the RTC's power fail flag is reset and the power up/down timestamps are cleared. void squareWave(uint8_t freq); Enables or disables the square wave output on the multi-function pin (MFP). freq is one of the following: SQWAVE_1_HZ, SQWAVE_4096_HZ, SQWAVE_8192_HZ, SQWAVE_32768_HZ, SQWAVE_NONE void setAlarm(uint8_t alarmNumber, time_t alarmTime); Set an alarm time. Sets the alarm registers only, does not enable the alarm, use enableAlarm() for that. alarmNumber is 0 or 1, but is ruthlessly masked to ensure this is so. void enableAlarm(uint8_t alarmNumber, uint8_t alarmType); Enable or disable the given alarm (0 or 1). alarmNumber is masked to ensure a value of 0 or 1. alarmType is one of the following: ALM_MATCH_SECONDS, ALM_MATCH_MINUTES, ALM_MATCH_HOURS, ALM_MATCH_DAY, ALM_MATCH_DATE, ALM_MATCH_DATETIME, ALM_DISABLE boolean alarm(uint8_t alarmNumber); Tests whether the given alarm (0 or 1) has been triggered, returns true if triggered, else false. Clears the alarm flag to trap the next trigger event can be trapped. void out(boolean level); Sets the logic level on the MFP when it's not being used as a square wave or alarm output. The default is HIGH. void alarmPolarity(boolean polarity); Specifies the logic level on the Multi-Function Pin (MFP) when an alarm is triggered. The default is HIGH. When both alarms are active, the two are ORed together to determine the level of the MFP. With alarm polarity set to LOW (the default), this causes the MFP to go low only when BOTH alarms are triggered. With alarm polarity set to HIGH, the MFP will go high when EITHER alarm is triggered. Note that the state of the MFP is independent of the alarm "interrupt" flags, and the alarm() function will indicate when an alarm is triggered regardless of the polarity.