pax_global_header00006660000000000000000000000064132622311270014511gustar00rootroot0000000000000052 comment=8bf0ca246adcbab91d44569c04337307784c2202 MCP79412RTC-1.0.1/000077500000000000000000000000001326223112700131075ustar00rootroot00000000000000MCP79412RTC-1.0.1/.gitignore000066400000000000000000000000131326223112700150710ustar00rootroot00000000000000ReadMe.txt MCP79412RTC-1.0.1/LICENSE.md000066400000000000000000000010401326223112700145060ustar00rootroot00000000000000# Arduino MCP79412 RTC Library v1.0 # https://github.com/JChristensen/MCP79412RTC LICENSE file Jack Christensen Sep 2012 ![CC BY-SA](http://mirrors.creativecommons.org/presskit/buttons/88x31/png/by-sa.png) ## CC BY-SA ## Arduino MCP79412RTC Library by Jack Christensen 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 444 Castro Street, Suite 900 Mountain View, CA 94041 MCP79412RTC-1.0.1/README.md000066400000000000000000000474341326223112700144020ustar00rootroot00000000000000# Arduino MCP79412 RTC Library https://github.com/JChristensen/MCP79412RTC ReadMe file Jack Christensen Sep-2012 ![CC BY-SA](http://mirrors.creativecommons.org/presskit/buttons/80x15/png/by-sa.png) ## Introduction **MCP79412RTC** is an Arduino library that supports the Microchip MCP7941x Real-Time Clock/Calendar chips. It is intended to be used with the [Arduino Time library] (http://www.arduino.cc/playground/Code/Time). The **MCP79412RTC** library is a drop-in replacement for the **DS1307RTC** library by Michael Margolis that is supplied with the [Arduino Time library](http://www.arduino.cc/playground/Code/Time). To change from using a DS1307 RTC to an MCP7941x RTC, it is only necessary to use `#include ` instead of `#include `. The **MCP79412RTC** library also implements methods to support the additional features of the MCP7941x RTC. **For more information on the MCP79412, see:** [My Blog Post](http://goo.gl/MkBnjR), summarizing the features and advantages of the MCP79412 [My Power Outage Logger Project](http://goo.gl/RfM5os), an Arduino-based project featuring the MCP79412 The [Microchip MCP79412 Product Page](http://goo.gl/SHfKe0) for specs, datasheet, etc. MCP79411 and MCP79412 breakout boards are available at [my Tindie Store](http://goo.gl/UzAVcZ) ## Installation To use the **MCP79412RTC** library: - Go to https://github.com/JChristensen/MCP79412RTC, click the **Download ZIP** button and save the ZIP file to a convenient location on your PC. - Uncompress the downloaded file. This will result in a folder containing all the files for the library, that has a name that includes the branch name, usually **MCP79412RTC-master**. - Rename the folder to just **MCP79412RTC**. - Copy the renamed folder to the Arduino sketchbook\libraries folder. ## Examples The following example sketches are included with the **MCP79412RTC** library: - **rtcSet1:** Set the RTC date and time using a hard-coded value in the sketch. - **rtcSet2:** Similar to **rtcSet1**, a different way to hard-code the date and time. - **rtcSet3:** Set the RTC to the sketch compile date and time. - **SetSerial:** Set the RTC's date, time, and calibration register from the Arduino serial monitor. - **rtcSetSerial:** Set the RTC via input from the Arduino serial monitor. - **TimeRTC:** Same as the example of the same name provided with the **Time** library, demonstrating the interchangeability of the **MCP79412RTC** library with the **DS1307RTC** library. - **PowerOutageLogger:** A comprehensive example that implements a power failure logger using the MCP79412's ability to capture power down and power up times. Power failure events are logged to the MCP79412's SRAM. Output is to the Arduino serial monitor. - **tiny79412_KnockBang:** Demonstrates interfacing an ATtiny45/85 to the MCP79412. ## Usage notes Similar to the **DS1307RTC** library, the **MCP79412RTC** library instantiates an RTC object; the user does not need to do this. To use the **MCP79412RTC** library, the Time and Wire libraries must also be included. For brevity, these includes are not repeated in the examples below: ```c++ #include //http://github.com/JChristensen/MCP79412RTC #include //http://www.arduino.cc/playground/Code/Time #include //http://arduino.cc/en/Reference/Wire (included with Arduino IDE) ``` ## Methods for setting and reading the time ### get(void) ##### Description Reads the current date and time from the RTC and returns it as a *time_t* value. Returns zero if an I2C error occurs (RTC not present, etc.). ##### Syntax `RTC.get();` ##### Parameters None. ##### Returns Current date and time *(time_t)* ##### Example ```c++ time_t myTime; myTime = RTC.get(); ``` ### set(time_t t) ##### Description Sets the RTC date and time to the given *time_t* value. ##### Syntax `RTC.set(t);` ##### Parameters **t:** The date and time to set the RTC to *(time_t)* ##### Returns None. ##### Example ```c++ //this example first sets the system time (maintained by the Time library) to //a hard-coded date and time, and then sets the RTC from the system time. //the setTime() function is part of the Time library. setTime(23, 31, 30, 13, 2, 2009); //set the system time to 23h31m30s on 13Feb2009 RTC.set(now()); //set the RTC from the system time ``` ### read(tmElements_t &tm) ##### Description Reads the current date and time from the RTC and returns it as a *tmElements_t* structure. Returns *false* if an I2C error occurs (RTC not present, etc.). See the [Arduino Time library](http://www.arduino.cc/playground/Code/Time) for details on the *tmElements_t* structure. ##### Syntax `RTC.read(tm);` ##### Parameters **tm:** Address of a *tmElements_t* structure to which the date and time are returned. ##### Returns False if an I2C error occurred, else true. The date and time read from the RTC are returned to the **tm** parameter. ##### Example ```c++ tmElements_t tm; RTC.read(tm); Serial.print(tm.Hour, DEC); Serial.print(':'); Serial.print(tm.Minute,DEC); Serial.print(':'); Serial.println(tm.Second,DEC); ``` ### write(tmElements_t &tm) ##### Description Sets the RTC to the date and time given by a *tmElements_t* structure. ##### Syntax `RTC.write(tm);` ##### Parameters **tm:** Address of a *tmElements_t* structure used to set the date and time. ##### Returns None. ##### Example ```c++ tmElements_t tm; tm.Hour = 23; //set the tm structure to 23h31m30s on 13Feb2009 tm.Minute = 31; tm.Minute = 30; tm.Day = 13; tm.Month = 2; tm.Year = 2009 - 1970; //tmElements_t.Year is the offset from 1970 RTC.write(tm); //set the RTC from the tm structure ``` ### isRunning(void) ##### Description Returns a boolean value indicating whether the RTC's oscillator is running. When there is no backup battery present, the RTC will reset when it is next powered up, and the oscillator will not be running. Setting the time with `RTC.set()` or `RTC.write()` starts the oscillator. ##### Syntax `RTC.isRunning();` ##### Parameters None. ##### Returns True if the RTC's oscillator is running, else false *(boolean)* ##### Example ```c++ if ( RTC.isRunning() ) //do something else //do something else ``` ## Methods for reading and writing static RAM (SRAM) The MCP79412 RTC has 64 bytes of battery-backed SRAM that can be read and written with the following methods using addresses between 0 and 63. Addresses passed to these functions are constrained to the valid range by an AND function. ### sramWrite(byte addr, byte value) ##### Description Writes a single byte to the SRAM. ##### Syntax `RTC.sramWrite(addr, value);` ##### Parameters **addr:** SRAM address to write *(byte)* **value:** Value to write *(byte)* ##### Returns None. ##### Example ```c++ RTC.sramWrite(3, 14); //write the value 14 to SRAM address 3 ``` ### sramWrite(byte addr, byte *values, byte nBytes) ##### Description Writes multiple bytes to consecutive SRAM locations. *nBytes* must be between 1 and 31. Invalid values of *nBytes*, or combinations of *addr* and *nBytes* that would result in addressing past the last byte of SRAM will result in no action. ##### Syntax `RTC.sramWrite(addr, values, nBytes);` ##### Parameters **addr:** First SRAM address to write *(byte)* **value:** An array of values to write _(*byte)_ **nBytes:** Number of bytes to write *(byte)* ##### Returns None. ##### Example ```c++ //write 1, 2, ..., 8 to the first eight SRAM locations byte buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; RTC.sramWrite(0, buf, 8); ``` ### sramRead(byte addr) ##### Description Reads a single byte from SRAM. ##### Syntax `RTC.sramRead(addr);` ##### Parameters **addr:** SRAM address to read *(byte)* ##### Returns The value read *(byte)* ##### Example ```c++ byte val; val = RTC.sramRead(3); //read the value from SRAM location 3 ``` ### sramRead(byte addr, byte *values, byte nBytes) ##### Description Reads multiple bytes from consecutive SRAM locations. nBytes must be between 1 and 32. Invalid values of *nBytes*, or combinations of *addr* and *nBytes* that would result in addressing past the last byte of SRAM will result in no action. ##### Syntax `RTC.sramRead(addr, values, nBytes);` ##### Parameters **addr:** First SRAM address to read *(byte)* **values:** An array to receive the read values _(*byte)_ **nBytes:** Number of bytes to read *(byte)* ##### Returns No function value returned. Bytes read from SRAM are returned to the **values** array. ##### Example ```c++ //read the last eight locations of SRAM into buf byte buf[8]; RTC.sramRead(56, buf, 8); ``` ## Methods for Reading and writing EEPROM The MCP79412 RTC has 128 bytes of non-volatile EEPROM that can be read and written with the following methods using addresses between 0 and 127. Addresses passed to these functions are constrained to the valid range by an AND function. EEPROM is paged memory with a page size of 8 bytes; when writing multiple bytes, this this limits the number of bytes that can be written at one time to 8. Page writes must start on a page boundary. ### eepromWrite(byte addr, byte value) ##### Description Writes a single byte to EEPROM. ##### Syntax `RTC.eepromWrite(addr, value);` ##### Parameters **addr:** EEPROM address to write *(byte)* **value:** Value to write *(byte)* ##### Returns None. ##### Example ```c++ RTC.eepromWrite(42, 55); //write the value 55 to EEPROM address 42 ``` ### eepromWrite(byte addr, byte *values, byte nBytes) ##### Description Writes a page (8 bytes) or less to EEPROM. *addr* should be a page start address (0, 8, ..., 120), but if not, is ruthlessly coerced into a valid value with an AND function. *nBytes* must be between 1 and 8, other values result in no action. ##### Syntax `RTC.eepromWrite(addr, values, nBytes);` ##### Parameters **addr:** First EEPROM address to write *(byte)* **value:** An array of values to write _(*byte)_ **nBytes:** Number of bytes to write *(byte)* ##### Returns None. ##### Example ```c++ //write 1, 2, ..., 8 to the first eight EEPROM locations byte buf[8] = {1, 2, 3, 4, 5, 6, 7, 8}; RTC.eepromWrite(0, buf, 8); ``` ### eepromRead(byte addr) ##### Description Reads a single byte from EEPROM and returns the value. ##### Syntax `RTC.eepromRead(byte addr);` ##### Parameters **addr:** EEPROM address to read *(byte)* ##### Returns The value read *(byte)* ##### Example ```c++ byte val; val = RTC.eepromRead(42); //read the value from EEPROM location 42 ``` ### eepromRead(byte addr, byte *values, byte nBytes) ##### Description Reads multiple bytes from consecutive EEPROM locations. *nBytes* must be between 1 and 32. Invalid values of *nBytes*, or combinations of *addr* and *nBytes* that would result in addressing past the last byte of EEPROM will result in no action. ##### Syntax `RTC.eepromRead(addr, values, nBytes);` ##### Parameters **addr:** First EEPROM address to read *(byte)* **values:** An array to receive the read values _(*byte)_ **nBytes:** Number of bytes to read *(byte)* ##### Returns No function value returned. The bytes read from EEPROM are returned to the **values** array. ##### Example ```c++ //read the last eight locations of EEPROM into buf byte buf[8]; RTC.eepromRead(120, buf, 8); ``` ## Alarm methods The MCP79412 RTC has two alarms (Alarm-0 and Alarm-1) that can be used separately or simultaneously. When an alarm is triggered, a flag is set in the RTC that can be detected with the `alarm()` function below. Optionally, the RTC's Multi-Function Pin (MFP) can be driven to either a low or high logic level when an alarm is triggered. When using the MFP with both alarms, be sure to read the comments on the `alarmPolarity()` function below. ### setAlarm(byte alarmNumber, time_t alarmTime) ##### Description Sets an alarm date and time. This *sets* the alarm registers only, it does not *enable* the alarm, this is done using the `enableAlarm()` function. *alarmNumber* is 0 or 1, but is ruthlessly masked to ensure a valid value. Note that depending on the alarm type chosen (see `enableAlarm()` below), only selected date or time parts may act as alarm critera. Nevertheless, valid values should be specified in the *alarmTime* parameter. ##### Syntax `RTC.setAlarm(alarmNumber, alarmTime);` ##### Parameters **alarmNumber:** ALARM_0 or ALARM_1 *(byte)* **alarmTime:** Date and time to set the alarm to *(time_t)* ##### Returns None. ##### Example ```c++ //set alarm-1 for 30 seconds after midnight on 21Dec2012 tmElements_t tm; tm.Hour = 0; tm.Minute = 0; tm.Second = 30; tm.Year = CalendarYrToTm(2012); tm.Month = 12; tm.Day = 21; RTC.setAlarm(ALARM_1, makeTime(tm)); ``` ### enableAlarm(byte alarmNumber, byte alarmType) ##### Description Enable or disable the given alarm. ##### Syntax `RTC.enableAlarm(alarmNumber, alarmType);` ##### Parameters **alarmNumber:** ALARM_0 or ALARM_1 *(byte)* **alarmType:** One of the following: ALM_MATCH_SECONDS, ALM_MATCH_MINUTES, ALM_MATCH_HOURS, ALM_MATCH_DAY, ALM_MATCH_DATE, ALM_MATCH_DATETIME, ALM_DISABLE. (ALM_MATCH_DATETIME triggers the alarm when seconds, minutes, hours, day, date and month *all* match.) ##### Returns None. ##### Example ```c++ //disable alarm-0 RTC.enableAlarm(ALARM_0, ALM_DISABLE); //enable alarm-1 to trigger when the minutes match. //assuming alarm-1 is set as in the example above, this will trigger the //alarm every hour, on the hour (minutes=0). RTC.enableAlarm(ALARM_1, ALM_MATCH_MINUTES); //enable alarm-1 to trigger when the seconds match. //assuming alarm-1 is set as in the example above, this will trigger the //alarm once a minute, at 30 seconds past the minute. RTC.enableAlarm(ALARM_1, ALM_MATCH_SECONDS); ``` ### alarm(byte alarmNumber) ##### Description Tests whether the given alarm has been triggered, and returns a corresponding boolean value. Clears the alarm flag to ensure that the next trigger event can be trapped. ##### Syntax `RTC.alarm(byte alarmNumber);` ##### Parameters **alarmNumber:** ALARM_0 or ALARM_1 *(byte)* ##### Returns True if the alarm was triggered, else false *(boolean)* ##### Example ```c++ if ( RTC.alarm(ALARM_0) ) //alarm-0 has triggered else //alarm-0 has not triggered ``` ### alarmPolarity(boolean polarity) ##### Description Specifies the logic level on the Multi-Function Pin (MFP) when an alarm is triggered. The default is LOW. 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 RTC's (so-called) alarm "interrupt" flags, and that the `alarm()` function will indicate when an alarm is triggered regardless of the polarity. ##### Syntax `RTC.alarmPolarity(boolean polarity);` ##### Parameters **polarity:** HIGH or LOW *(boolean)* ##### Returns None. ##### Example ```c++ RTC.alarmPolarity(HIGH); //drives MFP high when an alarm is triggered ``` ## Calibration, power failure, and other methods ### calibWrite(int value) ##### Description Writes the given value to the RTC calibration register. This is an adjustment factor in PPM (approximately), and must be between -127 and 127. Negative numbers cause the RTC to run faster, positive numbers cause it to run slower. ##### Syntax `RTC.calibWrite(int value);` ##### Parameters **value:** The calibration value to set, between -127 and 127 *(int)* ##### Returns None. ##### Example ```c++ RTC.calibWrite(13); //makes the RTC run slower by 13 parts per million. RTC.calibWrite(-42); //makes the RTC run faster by 42 parts per million. ``` ### calibRead(void) ##### Description Reads the RTC calibration register. ##### Syntax `RTC.calibRead(void);` ##### Parameters None. ##### Returns RTC calibration register value *(int)* ##### Example ```c++ int value; value = RTC.calibRead(); ``` ### powerFail(time_t *powerDown, time_t *powerUp) ##### Description Returns a boolean value (true or false) to indicate whether a power failure has occurred. If a power failure 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. Note that the power down and power up timestamp registers do not contain values for seconds or for the year. The returned time stamps will therefore contain the current year from the RTC. However, there is the possibility that a power outage spans from one year to the next. If this occurs, the power down timestamp would appear to be at a later time than the power up timestamp; if this is encountered, `powerFail()` will subtract one year from the power down timestamp before returning it. Still, there is an assumption that the timestamps are being read in the same year as that when the power up occurred. If this is not the case the year in the returned timestamp will be invalid. Finally, note that once the RTC records a power outage, it must be cleared before another can be recorded. If two power outages occur before `powerFail()` is called again, the time stamps for the earlier outage will be returned and the timestamps for the second outage will be lost. ##### Syntax `RTC.powerFail(powerDown, powerUp);` ##### Parameters **powerDown:** Pointer to a *time_t* variable to hold the returned power down timestamp. **powerUp:** Pointer to a *time_t* variable to hold the returned power up timestamp. ##### Returns True if a power failure occurred, else false *(boolean)* ##### Example ```c++ time_t powerDown, powerUp; //power outage timestamps if ( RTC.powerFail(&powerDown, &powerUp) ) { //do something else //do something else ``` ### squareWave(byte freq) ##### Description Enables or disables the square wave output on the multi-function pin (MFP). ##### Syntax `RTC.squareWave(byte freq);` ##### Parameters **freq:** One of the following: SQWAVE_1_HZ, SQWAVE_4096_HZ, SQWAVE_8192_HZ, SQWAVE_32768_HZ, SQWAVE_NONE *(byte)* ##### Returns None. ##### Example ```c++ RTC.squareWave(SQWAVE_1_HZ); //output a 1Hz square wave on the MFP ``` -------------------------------------------------------------------------------- ### out(boolean level) ##### Description Sets the logic level on the MFP when it's not being used as a square wave or alarm output. The default value after the RTC chip is reset is HIGH. ##### Syntax `RTC.out(boolean level);` ##### Parameters **level**: HIGH or LOW *(boolean)* ##### Returns None. ##### Example ```c++ RTC.out(LOW); //set the MFP to a low logic level ``` -------------------------------------------------------------------------------- ### idRead(byte *uniqueID) ##### Description Reads the 64-bit unique ID from the RTC. ##### Syntax `RTC.idRead(byte *uniqueID);` ##### Parameters **uniqueID:** An 8-byte array to receive the unique ID _(*byte)_ ##### Returns No function value returned. The RTC's ID is returned to the **uniqueID** array. ##### Example ```c++ byte buf[8]; RTC.idRead(buf); ``` -------------------------------------------------------------------------------- ### vbaten(boolean enable) ##### Description Set or clear the VBATEN bit. Setting the bit powers the clock and SRAM from the backup battery when Vcc falls. Note that setting the time via set() or write() sets the VBATEN bit. ##### Syntax `RTC.vbaten(boolean enable);` ##### Parameters **enable:** true or false *(boolean)* ##### Returns None. ##### Example ```c++ RTC.vbaten(false); ``` -------------------------------------------------------------------------------- ### getEUI64(byte *uniqueID) ##### Description Returns an EUI-64 ID. For an MCP79412, calling this function is equivalent to calling `idRead()`. For an MCP79411, the EUI-48 ID is converted to EUI-64. Caller must provide an 8-byte array to contain the results. ##### Syntax `RTC.getEUI64(byte *uniqueID);` ##### Parameters **uniqueID:** An 8-byte array to receive the EUI-64 unique ID _(*byte)_ ##### Returns No function value returned. The EUI-64 ID is returned to the **uniqueID** array. ##### Example ```c++ byte buf[8]; RTC.getEUI64(buf); ``` MCP79412RTC-1.0.1/examples/000077500000000000000000000000001326223112700147255ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/PowerOutageLogger/000077500000000000000000000000001326223112700203265ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/PowerOutageLogger/PowerOutageLogger.pde000066400000000000000000000173201326223112700244240ustar00rootroot00000000000000/*----------------------------------------------------------------------* * 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 //http://github.com/JChristensen/MCP79412RTC #include //http://arduiniana.org/libraries/streaming/ #include //http://playground.arduino.cc/Code/Time #include //http://arduino.cc/en/Reference/Wire void setup(void) { byte rtcID[8]; Serial.begin(115200); //setSyncProvider() causes the Time library to synchronize with the //external RTC by calling RTC.get() every five minutes by default. setSyncProvider(RTC.get); Serial << endl << F("RTC Sync"); if (timeStatus() != timeSet) Serial << F(" FAIL!"); Serial << endl; RTC.idRead(rtcID); Serial << F("RTC ID = "); for (int i=0; i<8; ++i) { if (rtcID[i] < 16) Serial << '0'; Serial << _HEX(rtcID[i]); } Serial << endl; RTC.getEUI64(rtcID); Serial << F("EUI-64 = "); for (int i=0; i<8; ++i) { if (rtcID[i] < 16) Serial << '0'; Serial << _HEX(rtcID[i]); } Serial << endl; Serial << F("Calibration Register = ") << RTC.calibRead() << endl; } void loop(void) { static time_t tLast; time_t t; tmElements_t tm; int cmdChar, y, oldCal, newCal; //check for input, first character is a command, "S" to set date/time, or "C" to set the calibration register if (Serial.available()) { cmdChar = Serial.read(); switch (cmdChar) { case 'S': case 's': //note that the tmElements_t Year member is an offset from 1970, //but the RTC wants the last two digits of the calendar year. //use the convenience macros from Time.h to do the conversions. y = Serial.parseInt(); if (y >= 100 && y < 1000) Serial << F("Error: Year must be two digits or four digits!") << endl; else { if (y >= 1000) tm.Year = CalendarYrToTm(y); else //(y < 100) tm.Year = y2kYearToTm(y); tm.Month = Serial.parseInt(); tm.Day = Serial.parseInt(); tm.Hour = Serial.parseInt(); tm.Minute = Serial.parseInt(); tm.Second = Serial.parseInt(); t = makeTime(tm); RTC.set(t); //use the time_t value to ensure correct weekday is set setTime(t); Serial << F("RTC set to: "); printDateTime(t); Serial << endl; } break; case 'C': case 'c': newCal = Serial.parseInt(); oldCal = RTC.calibRead(); RTC.calibWrite(newCal); Serial << F("Calibration changed from ") << oldCal << F(" to ") << RTC.calibRead() << endl; break; default: Serial << endl << F("Unrecognized command: ") << (char)cmdChar << endl; break; } //dump any extraneous input while (Serial.available() > 0) Serial.read(); } t = now(); if (t != tLast) { tLast = t; printDateTime(t); Serial << endl; } } //print date and time to Serial void printDateTime(time_t t) { printDate(t); Serial << ' '; printTime(t); } //print time to Serial void printTime(time_t t) { printI00(hour(t), ':'); printI00(minute(t), ':'); printI00(second(t), ' '); } //print date to Serial void printDate(time_t t) { printI00(day(t), 0); Serial << monthShortStr(month(t)) << _DEC(year(t)); } //Print an integer in "00" format (with leading zero), //followed by a delimiter character to Serial. //Input value assumed to be between 0 and 99. void printI00(int val, char delim) { if (val < 10) Serial << '0'; Serial << _DEC(val); if (delim > 0) Serial << delim; return; }MCP79412RTC-1.0.1/examples/TimeRTC/000077500000000000000000000000001326223112700161745ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/TimeRTC/TimeRTC.pde000066400000000000000000000022451326223112700201400ustar00rootroot00000000000000/* * TimeRTC.pde * Example code illustrating Time library with Real Time Clock. * This example is identical to the example provided with the Time Library, * only the #include statement has been changed to include the MCP79412RTC library. */ #include #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-1.0.1/examples/rtcSet1/000077500000000000000000000000001326223112700162525ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/rtcSet1/rtcSet1.pde000066400000000000000000000046171326223112700203010ustar00rootroot00000000000000/*----------------------------------------------------------------------* * Example sketch for Arduino MCP79412 Library by Jack Christensen * * * * Sets the RTC date and time to a hard-coded value. * * This is just a simple demonstration of setting the RTC time. * * Note that each time the sketch is run (or the microcontroller is * * reset), the RTC will be set to the same hard-coded time, so this * * example may be of limited usefulness as an actual clock. * * * * 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://www.arduino.cc/playground/Code/Time #include //http://arduino.cc/en/Reference/Wire (included with Arduino IDE) void setup(void) { delay(2000); Serial.begin(9600); setTime(23, 31, 30, 13, 2, 2009); //set the system time to 23h31m30s on 13Feb2009 //the setTime() function is from the Time.h library. //setTime(hour, minute, second, day, month, year); RTC.set(now()); //set the RTC from the system time } void loop(void) { printTime(now()); delay(1000); } //Print time (and date) given a time_t value void printTime(time_t t) { printI00(hour(t), ':'); printI00(minute(t), ':'); printI00(second(t), ' '); Serial.print(dayShortStr(weekday(t))); Serial.print(' '); printI00(day(t), ' '); Serial.print(monthShortStr(month(t))); Serial.print(' '); Serial.println(year(t)); } //Print an integer in "00" format (with leading zero), //followed by a delimiter. //Input value assumed to be between 0 and 99. void printI00(int val, char delim) { if (val < 10) Serial.print('0'); Serial.print(val); Serial.print(delim); return; } MCP79412RTC-1.0.1/examples/rtcSet2/000077500000000000000000000000001326223112700162535ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/rtcSet2/rtcSet2.pde000066400000000000000000000047131326223112700203000ustar00rootroot00000000000000/*----------------------------------------------------------------------* * Example sketch for Arduino MCP79412 Library by Jack Christensen * * * * Sets the RTC date and time to a hard-coded value, using a * * tmElements_t structure. The same structure is then used to * * read the RTC once per second. This sketch only uses the Time * * library for the tmElements_t definition. * * * * This is just a simple demonstration of setting the RTC time. * * Note that each time the sketch is run (or the microcontroller is * * reset), the RTC will be set to the same hard-coded time, so this * * example may be of limited usefulness as an actual clock. * * * * 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://www.arduino.cc/playground/Code/Time #include //http://arduino.cc/en/Reference/Wire (included with Arduino IDE) tmElements_t tm; void setup(void) { delay(2000); Serial.begin(9600); tm.Hour = 23; //set the tm structure to 23h31m30s on Fri 13Feb2009 tm.Minute = 31; tm.Second = 30; tm.Year = 2009 - 1970; //tmElements_t.Year is the offset from 1970. tm.Month = 2; tm.Day = 13; tm.Wday = dowFriday; //See enum in Time.h: Sun=1, Mon=2, ... Sat=7 RTC.write(tm); //set the RTC from the tm structure } void loop(void) { RTC.read(tm); Serial.print(tm.Hour, DEC); Serial.print(':'); Serial.print(tm.Minute,DEC); Serial.print(':'); Serial.print(tm.Second,DEC); Serial.print(' '); Serial.print(tm.Year + 1970, DEC); Serial.print('-'); Serial.print(tm.Month, DEC); Serial.print('-'); Serial.print(tm.Day, DEC); Serial.println(); delay(1000); } MCP79412RTC-1.0.1/examples/rtcSet3/000077500000000000000000000000001326223112700162545ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/rtcSet3/rtcSet3.pde000066400000000000000000000055511326223112700203030ustar00rootroot00000000000000/*----------------------------------------------------------------------* * Example sketch for Arduino MCP79412 Library by Jack Christensen * * * * Sets the RTC date and time to the sketch compile time. * * Re-running this sketch by pressing the reset button, etc., will * * cause the RTC time to be reset to the *same* compile time. * * Upload the sketch again to recompile it with the current time. * * * * 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://www.arduino.cc/playground/Code/Time #include //http://arduino.cc/en/Reference/Wire (included with Arduino IDE) void setup(void) { delay(2000); Serial.begin(9600); setTime(compileTime()); //set the system time to the sketch compile time RTC.set(now()); //set the RTC from the system time } void loop(void) { printTime(now()); delay(1000); } //Function to return the compile date and time as a time_t value time_t compileTime(void) { #define FUDGE 15 //fudge factor to allow for compile time (seconds, YMMV) char *compDate = __DATE__, *compTime = __TIME__, *months = "JanFebMarAprMayJunJulAugSepOctNovDec"; char chMon[3], *m; int d, y; tmElements_t tm; time_t t; strncpy(chMon, compDate, 3); chMon[3] = '\0'; m = strstr(months, chMon); tm.Month = ((m - months) / 3 + 1); tm.Day = atoi(compDate + 4); tm.Year = atoi(compDate + 7) - 1970; tm.Hour = atoi(compTime); tm.Minute = atoi(compTime + 3); tm.Second = atoi(compTime + 6); t = makeTime(tm); return t + FUDGE; //add fudge factor to allow for compile time } //Print time (and date) given a time_t value void printTime(time_t t) { printI00(hour(t), ':'); printI00(minute(t), ':'); printI00(second(t), ' '); Serial.print(dayShortStr(weekday(t))); Serial.print(' '); printI00(day(t), ' '); Serial.print(monthShortStr(month(t))); Serial.print(' '); Serial.println(year(t)); } //Print an integer in "00" format (with leading zero), //followed by a delimiter. //Input value assumed to be between 0 and 99. void printI00(int val, char delim) { if (val < 10) Serial.print('0'); Serial.print(val); Serial.print(delim); return; } MCP79412RTC-1.0.1/examples/rtcSetSerial/000077500000000000000000000000001326223112700173315ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/rtcSetSerial/rtcSetSerial.pde000066400000000000000000000103521326223112700224300ustar00rootroot00000000000000/*----------------------------------------------------------------------* * Example sketch for Arduino MCP79412 Library by Jack Christensen * * * * Set the RTC by entering a "Set" command on the serial monitor. * * Use a 24-hour clock and enter the command (case sensitive) exactly * * as follows: Set yyyy-mm-dd hh:mm:ss * * * * 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://www.arduino.cc/playground/Code/Time #include //http://arduino.cc/en/Reference/Wire (included with Arduino IDE) #define PRINT_INTERVAL 1000 //ms between printing the time unsigned long ms, msLast; void setup() { delay(2000); Serial.begin(9600); setSyncProvider(RTC.get); //the function to get the time from the RTC Serial.print("RTC SYNC"); if (timeStatus() != timeSet) Serial.print(" FAIL"); Serial.println(); } void loop(void) { ms = millis(); readCommand(); if (ms - msLast >= PRINT_INTERVAL) { msLast = ms; printTime(now()); } } //Read command from the Arduino serial monitor to set the RTC. //Case-sensitive and must be entered exactly as (24-hour clock): // Set yyyy-mm-dd hh:mm:ss void readCommand() { char cmd[24] = "Set yyyy-mm-dd hh:mm:ss"; static int i; tmElements_t tmSet; time_t tSet; if (Serial.available() >= 23) { //enough characters for the whole command? i = 0; //yes, read the available characters while (Serial.available() > 0) { if (i >= sizeof(cmd) - 1) { //more than we can enjoy flushInput(); //clear out the input buffer Serial.print("Too long: "); Serial.println(cmd); return; } delay(2); //let the next character trickle in cmd[i++] = char(Serial.read()); } cmd[i] = 0; //put in string terminator if (strncmp(cmd, "Set ", 4) == 0) { tmSet.Year = 1000 * (cmd[4] - '0') + 100 * (cmd[5] - '0') + 10 * (cmd[6] - '0') + cmd[7] - '0' - 1970; tmSet.Month = 10 * (cmd[9] - '0') + cmd[10] - '0'; tmSet.Day = 10 * (cmd[12] - '0') + cmd[13] - '0'; tmSet.Hour = 10 * (cmd[15] - '0') + cmd[16] - '0'; tmSet.Minute = 10 * (cmd[18] - '0') + cmd[19] - '0'; tmSet.Second = 10 * (cmd[21] - '0') + cmd[22] - '0'; tSet = makeTime(tmSet); //convert to time_t setTime(tSet); //set the system time RTC.set(now()); //set the rtc Serial.println("RTC set!"); flushInput(); //discard any extraneous trailing characters } else { Serial.print("Unknown: "); Serial.println(cmd); } } } void flushInput(void) { do { delay(2); Serial.read(); } while (Serial.available() > 0); } //Print time (and date) given a time_t value void printTime(time_t t) { printI00(hour(t), ':'); printI00(minute(t), ':'); printI00(second(t), ' '); Serial.print(dayShortStr(weekday(t))); Serial.print(' '); printI00(day(t), ' '); Serial.print(monthShortStr(month(t))); Serial.print(' '); Serial.println(year(t)); } //Print an integer in "00" format (with leading zero), //followed by a delimiter. //Input value assumed to be between 0 and 99. void printI00(int val, char delim) { if (val < 10) Serial.print('0'); Serial.print(val); Serial.print(delim); return; } MCP79412RTC-1.0.1/examples/tiny79412_KnockBang/000077500000000000000000000000001326223112700202345ustar00rootroot00000000000000MCP79412RTC-1.0.1/examples/tiny79412_KnockBang/tiny79412_KnockBang.ino000066400000000000000000000061421326223112700242550ustar00rootroot00000000000000/*----------------------------------------------------------------------* * Digital clock display using an MCP79412 Real-Time Clock/Calendar * * and an ATtiny45/85 with a 1MHz system clock. * * * * Tested with Arduino 1.0.5. Also Arduino-Tiny Core, TinyISP, and * * TinyDebugKnockBang from http://code.google.com/p/arduino-tiny/ * * * * Run TinyISP on an ATmega microcontroller that does not have an LED * * connected to pin 13 (SCK). The LED causes problems because the SPI * * pins are also the I2C pins on the ATtiny. Connect MISO, MOSI, SCK * * on the ATmega to the corresponding pins on the ATtiny through 220Ω * * resistors for safety. Use 4.7K pullup resistors on the ATtiny * * I2C bus. * * * * Jack Christensen 21Aug2013 * * * * 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://playground.arduino.cc/Code/Time #include //http://code.google.com/p/arduino-tiny/ #include //http://playground.arduino.cc/Code/USIi2c void setup(void) { Debug.begin(250000); //setSyncProvider() causes the Time library to synchronize with the //external RTC by calling RTC.get() every five minutes by default. setSyncProvider(RTC.get); Debug.print(F("RTC Sync")); if (timeStatus() != timeSet) Debug.print(F(" FAIL!")); Debug.println(); } void loop(void) { static time_t tLast; time_t t = now(); if (t != tLast) { tLast = t; printDateTime(t); Debug.println(); } } //print date and time to Serial void printDateTime(time_t t) { printDate(t); Debug.print(' '); printTime(t); } //print time to Serial void printTime(time_t t) { printI00(hour(t), ':'); printI00(minute(t), ':'); printI00(second(t), ' '); } //print date to Serial void printDate(time_t t) { printI00(day(t), 0); Debug.print(monthShortStr(month(t))); Debug.print(year(t), DEC); } //Print an integer in "00" format (with leading zero), //followed by a delimiter character to Serial. //Input value assumed to be between 0 and 99. void printI00(int val, char delim) { if (val < 10) Debug.print('0'); Debug.print(val, DEC);; if (delim > 0) Debug.print(delim); return; } MCP79412RTC-1.0.1/keywords.txt000066400000000000000000000005451326223112700155230ustar00rootroot00000000000000MCP79412RTC KEYWORD1 get KEYWORD2 set KEYWORD2 read KEYWORD2 write KEYWORD2 sramWrite KEYWORD2 sramRead KEYWORD2 eepromWrite KEYWORD2 eepromRead KEYWORD2 calibRead KEYWORD2 calibWrite KEYWORD2 idRead KEYWORD2 powerFail KEYWORD2 squareWave KEYWORD2 setAlarm KEYWORD2 enableAlarm KEYWORD2 alarm KEYWORD2 out KEYWORD2 alarmPolarity KEYWORD2 isRunning KEYWORD2 MCP79412RTC-1.0.1/library.properties000066400000000000000000000006141326223112700166720ustar00rootroot00000000000000name=MCP79412RTC version=1.0.1 author=Jack Christensen maintainer=Jack Christensen sentence=Arduino library for the Microchip MCP79411/12 Real-Time Clock/Calendar. paragraph=Requires the Arduino Time library, http://www.arduino.cc/playground/Code/Time category=Timing url=https://github.com/JChristensen/MCP79412RTC architectures=avr MCP79412RTC-1.0.1/src/000077500000000000000000000000001326223112700136765ustar00rootroot00000000000000MCP79412RTC-1.0.1/src/MCP79412RTC.cpp000066400000000000000000000665661326223112700160240ustar00rootroot00000000000000/*----------------------------------------------------------------------* * MCP79412RTC.cpp - Arduino library for the Microchip MCP7941x * * Real-Time Clocks. 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 MCP7941x 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 MCP7941x. * * * * 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 "MCP79412RTC.h" //define release-independent I2C functions #if defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) #include #define i2cBegin TinyWireM.begin #define i2cBeginTransmission TinyWireM.beginTransmission #define i2cEndTransmission TinyWireM.endTransmission #define i2cRequestFrom TinyWireM.requestFrom #define i2cRead TinyWireM.receive #define i2cWrite TinyWireM.send #elif ARDUINO >= 100 #include #define i2cBegin Wire.begin #define i2cBeginTransmission Wire.beginTransmission #define i2cEndTransmission Wire.endTransmission #define i2cRequestFrom Wire.requestFrom #define i2cRead Wire.read #define i2cWrite Wire.write #else #include #define i2cBegin Wire.begin #define i2cBeginTransmission Wire.beginTransmission #define i2cEndTransmission Wire.endTransmission #define i2cRequestFrom Wire.requestFrom #define i2cRead Wire.receive #define i2cWrite Wire.send #endif /*----------------------------------------------------------------------* * Constructor. * *----------------------------------------------------------------------*/ MCP79412RTC::MCP79412RTC() { i2cBegin(); } /*----------------------------------------------------------------------* * Read the current time from the RTC and return it as a time_t value. * * Returns a zero value if RTC not present (I2C I/O error). * *----------------------------------------------------------------------*/ time_t MCP79412RTC::get(void) { tmElements_t tm; if ( read(tm) ) return( makeTime(tm) ); else return 0; } /*----------------------------------------------------------------------* * 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. Returns false if RTC not present (I2C I/O error). * *----------------------------------------------------------------------*/ boolean MCP79412RTC::read(tmElements_t &tm) { i2cBeginTransmission(RTC_ADDR); i2cWrite((uint8_t)TIME_REG); if (i2cEndTransmission() != 0) { return false; } else { //request 7 bytes (secs, min, hr, dow, date, mth, yr) i2cRequestFrom(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())); return true; } } /*----------------------------------------------------------------------* * Set the RTC's time from a tmElements_t structure. * *----------------------------------------------------------------------*/ void MCP79412RTC::write(tmElements_t &tm) { i2cBeginTransmission(RTC_ADDR); i2cWrite((uint8_t)TIME_REG); i2cWrite((uint8_t)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))); i2cEndTransmission(); i2cBeginTransmission(RTC_ADDR); i2cWrite((uint8_t)TIME_REG); i2cWrite(dec2bcd(tm.Second) | _BV(ST)); //set the seconds and start the oscillator (Bit 7, ST == 1) i2cEndTransmission(); } /*----------------------------------------------------------------------* * 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 * * limitation). * *----------------------------------------------------------------------*/ void MCP79412RTC::ramWrite(byte addr, byte *values, byte nBytes) { i2cBeginTransmission(RTC_ADDR); i2cWrite(addr); for (byte i=0; i= 1 && (addr + nBytes) <= SRAM_SIZE) { #else if (nBytes >= 1 && nBytes <= (BUFFER_LENGTH - 1) && (addr + nBytes) <= SRAM_SIZE) { #endif 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 32 (Wire library * * limitation). * * Invalid values for 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 defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__) if (nBytes >= 1 && (addr + nBytes) <= SRAM_SIZE) { #else if (nBytes >= 1 && nBytes <= BUFFER_LENGTH && (addr + nBytes) <= SRAM_SIZE) { #endif 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) { i2cBeginTransmission(EEPROM_ADDR); i2cWrite( addr & (EEPROM_SIZE - 1) ); i2cWrite(value); i2cEndTransmission(); 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) { i2cBeginTransmission(EEPROM_ADDR); i2cWrite( addr & ~(EEPROM_PAGE_SIZE - 1) & (EEPROM_SIZE - 1) ); for (byte i=0; i= 1 && (addr + nBytes) <= EEPROM_SIZE) { #else if (nBytes >= 1 && nBytes <= BUFFER_LENGTH && (addr + nBytes) <= EEPROM_SIZE) { #endif i2cBeginTransmission(EEPROM_ADDR); i2cWrite( addr & (EEPROM_SIZE - 1) ); i2cEndTransmission(); i2cRequestFrom( (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. * * For the MCP79411 (EUI-48), the first two bytes will contain 0xFF. * * Caller must provide an 8-byte array to contain the results. * *----------------------------------------------------------------------*/ void MCP79412RTC::idRead(byte *uniqueID) { i2cBeginTransmission(EEPROM_ADDR); i2cWrite(UNIQUE_ID_ADDR); i2cEndTransmission(); i2cRequestFrom( EEPROM_ADDR, UNIQUE_ID_SIZE ); for (byte i=0; i *powerUp) { --dn.Year; *powerDown = makeTime(dn); } return true; } 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); i2cBeginTransmission(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)); i2cEndTransmission(); } /*----------------------------------------------------------------------* * 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 LOW. 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::isRunning(void) { i2cBeginTransmission(RTC_ADDR); i2cWrite((uint8_t)TIME_REG); i2cEndTransmission(); //request just the seconds register i2cRequestFrom(RTC_ADDR, 1); return i2cRead() & _BV(ST); } /*----------------------------------------------------------------------* * Set or clear the VBATEN bit. Setting the bit powers the clock and * * SRAM from the backup battery when Vcc falls. Note that setting the * * time via set() or write() sets the VBATEN bit. * *----------------------------------------------------------------------*/ void MCP79412RTC::vbaten(boolean enable) { uint8_t day; ramRead(DAY_REG, &day, 1); if (enable) day |= _BV(VBATEN); else day &= ~_BV(VBATEN); ramWrite(DAY_REG, &day, 1); return; } /*----------------------------------------------------------------------* * Decimal-to-BCD conversion * *----------------------------------------------------------------------*/ uint8_t MCP79412RTC::dec2bcd(uint8_t n) { return n + 6 * (n / 10); } /*----------------------------------------------------------------------* * BCD-to-Decimal conversion * *----------------------------------------------------------------------*/ uint8_t __attribute__ ((noinline)) MCP79412RTC::bcd2dec(uint8_t n) { return n - 6 * (n >> 4); } MCP79412RTC RTC = MCP79412RTC(); //instantiate an RTC object MCP79412RTC-1.0.1/src/MCP79412RTC.h000066400000000000000000000151311326223112700154470ustar00rootroot00000000000000/*----------------------------------------------------------------------* * MCP79412RTC.h - Arduino library for the Microchip MCP7941x * * Real-Time Clocks. 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 MCP7941x 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 MCP7941x. * * * * 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 //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 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 boolean 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); void getEUI64(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 isRunning(void); void vbaten(boolean enable); 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