// Arduino MCP79412RTC Library

// https://github.com/JChristensen/MCP79412RTC

// Copyright (C) 2018 by Jack Christensen and licensed under

// GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html

//

// Arduino library for the Microchip MCP7941x Real-Time Clocks.

// Requires PJRC's improved version of the Arduino Time Library,

// https://playground.arduino.cc/Code/Time

// https://github.com/PaulStoffregen/Time

//

// For AVR architecture, an MCP79412RTC object named RTC is instantiated

// by the library and I2C initialization occurs in the constructor;

// this is for backwards compatibility.

// For other architectures, the user needs to instantiate a MCP79412RTC

// object and optionally initialize the I2C bus by calling

// MCP79412RTC::begin(). The constructor has an optional bool parameter

// to indicate whether I2C initialization should occur in the

// constructor; this parameter defaults to true if not given.

#include <MCP79412RTC.h>

#include <stdlib.h>

#include "i2c.h"

#define i2cBegin i2c.begin

#define i2cBeginTransmission i2c.beginTransmission

#define i2cEndTransmission i2c.endTransmission

#define i2cRequestFrom i2c.requestFrom

#define i2cRead i2c.read

#define i2cWrite i2c.write

// 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

// 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.

// Constructor. Initializes the I2C bus by default, but better

// practice is to pass false in the constructor and call

// the begin() function in the setup code.

MCP79412RTC::MCP79412RTC(bool initI2C)

{

if (initI2C) i2cBegin();

}

// Initialize the I2C bus.

void MCP79412RTC::begin()

{

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()

{

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).

bool 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<nBytes; i++) i2cWrite(values[i]);

i2cEndTransmission();

}

// Read a single byte from RTC RAM.

// Valid address range is 0x00 - 0x5F, no checking.

byte MCP79412RTC::ramRead(byte addr)

{

byte value;

ramRead(addr, &value, 1);

return value;

}

// Read multiple bytes from RTC RAM.

// Valid address range is 0x00 - 0x5F, no checking.

// Number of bytes (nBytes) must be between 1 and 32 (Wire library

// limitation).

void MCP79412RTC::ramRead(byte addr, byte *values, byte nBytes)

{

i2cBeginTransmission(RTC_ADDR);

i2cWrite(addr);

i2cEndTransmission();

i2cRequestFrom( (uint8_t)RTC_ADDR, nBytes );

for (byte i=0; i<nBytes; i++) values[i] = i2cRead();

}

// Write a single byte to Static RAM.

// Address (addr) is constrained to the range (0, 63).

void MCP79412RTC::sramWrite(byte addr, byte value)

{

ramWrite( (addr & (SRAM_SIZE - 1) ) + SRAM_START_ADDR, &value, 1 );

}

// Write multiple bytes to Static RAM.

// Address (addr) is constrained to the range (0, 63).

// Number of bytes (nBytes) must be between 1 and 31 (Wire library

// limitation).

// Invalid values for nBytes, or combinations of addr and nBytes

// that would result in addressing past the last byte of SRAM will

// result in no action.

void MCP79412RTC::sramWrite(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 - 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<nBytes; i++) i2cWrite(values[i]);

i2cEndTransmission();

eepromWait();

}

}

// Read a single byte from EEPROM.

// Address (addr) is constrained to the range (0, 127).

byte MCP79412RTC::eepromRead(byte addr)

{

byte value;

eepromRead( addr & (EEPROM_SIZE - 1), &value, 1 );

return value;

}

// Read multiple bytes from EEPROM.

// Address (addr) is constrained to the range (0, 127).

// Number of bytes (nBytes) must be between 1 and 32 (Wire library

// limitation).

// Invalid values for addr or nBytes, or combinations of addr and

// nBytes that would result in addressing past the last byte of EEPROM

// result in no action.

void MCP79412RTC::eepromRead(byte addr, byte *values, byte nBytes)

{

#if defined(__AVR_ATtiny44__) || defined(__AVR_ATtiny84__) || defined(__AVR_ATtiny45__) || defined(__AVR_ATtiny85__)

if (nBytes >= 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<nBytes; i++) values[i] = i2cRead();

}

}

// Wait for EEPROM write to complete.

byte MCP79412RTC::eepromWait()

{

byte waitCount = 0;

byte txStatus;

do

{

++waitCount;

i2cBeginTransmission(EEPROM_ADDR);

i2cWrite((uint8_t)0);

txStatus = i2cEndTransmission();

} while (txStatus != 0);

return waitCount;

}

// Read the calibration register.

// The calibration value is not a twos-complement number. The MSB is

// the sign bit, and the 7 LSBs are an unsigned number, so we convert

// it and return it to the caller as a regular twos-complement integer.

int MCP79412RTC::calibRead()

{

byte val = ramRead(CALIB_REG);

if ( val & 0x80 ) return -(val & 0x7F);

else return val;

}

// Write the calibration register.

// Calibration value must be between -127 and 127, others result

// in no action. See note above on the format of the calibration value.

void MCP79412RTC::calibWrite(int value)

{

byte calibVal;

if (value >= -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<UNIQUE_ID_SIZE; i++) uniqueID[i] = i2cRead();

}

// Returns an EUI-64 ID. For an MCP79411, the EUI-48 ID is converted to

// EUI-64. For an MCP79412, calling this function is equivalent to

// calling idRead(). For an MCP79412, if the RTC type is known, calling

// idRead() will be a bit more efficient.

// Caller must provide an 8-byte array to contain the results.

void MCP79412RTC::getEUI64(byte *uniqueID)

{

byte rtcID[8];

idRead(rtcID);

if (rtcID[0] == 0xFF && rtcID[1] == 0xFF) {

rtcID[0] = rtcID[2];

rtcID[1] = rtcID[3];

rtcID[2] = rtcID[4];

rtcID[3] = 0xFF;

rtcID[4] = 0xFE;

}

for (byte i=0; i<UNIQUE_ID_SIZE; i++) uniqueID[i] = rtcID[i];

}

// Check to see if a power failure has occurred. If so, returns TRUE

// as the function value, and returns the power down and power up

// timestamps. After returning the time stamps, the RTC's timestamp

// registers are cleared and the VBAT bit which indicates a power

// failure is reset.

//

// 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 a chance that a power outage spans from one year to the next.

// If we find the power down timestamp to be later (larger) than the

// power up timestamp, we will assume this has happened, and

// subtract one year from the power down timestamp.

//

// Still, there is an assumption that the timestamps are being read

// in the same year as that when the power up occurred.

//

// Finally, note that once the RTC records a power outage, it must be

// cleared before another will be recorded.

bool MCP79412RTC::powerFail(time_t *powerDown, time_t *powerUp)

{

byte day, yr; // copies of the RTC Day and Year registers

tmElements_t dn, up; // power down and power up times

ramRead(DAY_REG, &day, 1);

ramRead(YEAR_REG, &yr, 1);

yr = y2kYearToTm(bcd2dec(yr));

if ( day & _BV(VBAT) ) {

i2cBeginTransmission(RTC_ADDR);

i2cWrite(PWRDWN_TS_REG);

i2cEndTransmission();

i2cRequestFrom(RTC_ADDR, TIMESTAMP_SIZE); // read both timestamp registers, 8 bytes total

dn.Second = 0;

dn.Minute = bcd2dec(i2cRead());

dn.Hour = bcd2dec(i2cRead() & ~_BV(HR1224)); // assumes 24hr clock

dn.Day = bcd2dec(i2cRead());

dn.Month = bcd2dec(i2cRead() & 0x1F); // mask off the day, we don't need it

dn.Year = yr; // assume current year

up.Second = 0;

up.Minute = bcd2dec(i2cRead());

up.Hour = bcd2dec(i2cRead() & ~_BV(HR1224)); // assumes 24hr clock

up.Day = bcd2dec(i2cRead());

up.Month = bcd2dec(i2cRead() & 0x1F); // mask off the day, we don't need it

up.Year = yr; // assume current year

*powerDown = makeTime(dn);

*powerUp = makeTime(up);

// clear the VBAT bit, which causes the RTC hardware to clear the timestamps too.

// I suppose there is a risk here that the day has changed since we read it,

// but the Day of Week is actually redundant data and the makeTime() function

// does not use it. This could be an issue if someone is reading the RTC

// registers directly, but as this library is meant to be used with the Time library,

// and also because we don't provide a method to read the RTC clock/calendar

// registers directly, we won't lose any sleep about it at this point unless

// some issue is actually brought to our attention ;-)

day &= ~_BV(VBAT);

ramWrite(DAY_REG, &day , 1);

// adjust the powerDown timestamp if needed (see notes above)

if (*powerDown > *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.

bool 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(bool 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(bool 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.

bool MCP79412RTC::isRunning()

{

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(bool 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;