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

// 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.
// Returns the I2C status (zero if successful).
uint8_t MCP79412RTC::set(const time_t t)
{
    tmElements_t tm;

    breakTime(t, tm);
    return ( 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(RTCSEC);
    if (i2cEndTransmission() != 0) {
        return false;
    }
    else {
        // request 7 bytes (secs, min, hr, dow, date, mth, yr)
        i2cRequestFrom(RTC_ADDR, static_cast<uint8_t>(tmNbrFields));
        tm.Second = bcd2dec(i2cRead() & ~_BV(STOSC));
        tm.Minute = bcd2dec(i2cRead());
        tm.Hour = bcd2dec(i2cRead() & ~_BV(HR1224));    // assumes 24hr clock
        tm.Wday = i2cRead() & ~(_BV(OSCRUN) | _BV(PWRFAIL) | _BV(VBATEN));  // mask off OSCRUN, PWRFAIL, VBATEN bits
        tm.Day = bcd2dec(i2cRead());
        tm.Month = bcd2dec(i2cRead() & ~_BV(LPYR));     // mask off the leap year bit
        tm.Year = y2kYearToTm(bcd2dec(i2cRead()));
        return true;
    }
}

// Set the RTC's time from a tmElements_t structure.
uint8_t MCP79412RTC::write(const tmElements_t& tm)
{
    i2cBeginTransmission(RTC_ADDR);
    i2cWrite(RTCSEC);
    i2cWrite(0x00);                             // stops the oscillator (Bit 7, STOSC == 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(RTCSEC);
    i2cWrite(dec2bcd(tm.Second) | _BV(STOSC));  // set the seconds and start the oscillator (Bit 7, STOSC == 1)
    uint8_t ret = i2cEndTransmission();
    return ret;
}

// Write a single byte to RTC RAM.
// Valid address range is 0x00 - 0x5F, no checking.
uint8_t MCP79412RTC::writeRTC(const uint8_t addr, const uint8_t value)
{
    return ( writeRTC(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).
uint8_t MCP79412RTC::writeRTC(const uint8_t addr, const uint8_t* values, const uint8_t nBytes)
{
    i2cBeginTransmission(RTC_ADDR);
    i2cWrite(addr);
    for (uint8_t i=0; i<nBytes; i++) i2cWrite(values[i]);
    return i2cEndTransmission();
}

// Read a single byte from RTC RAM.
// Valid address range is 0x00 - 0x5F, no checking.
uint8_t MCP79412RTC::readRTC(uint8_t addr)
{
    uint8_t value;

    readRTC(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).
uint8_t MCP79412RTC::readRTC(const uint8_t addr, uint8_t* values, const uint8_t nBytes)
{
    i2cBeginTransmission(RTC_ADDR);
    i2cWrite(addr);
    if ( uint8_t e = i2cEndTransmission() ) return e;
    i2cRequestFrom(RTC_ADDR, nBytes);
    for (uint8_t i=0; i<nBytes; i++) values[i] = i2cRead();
    return 0;
}

// Write a single byte to Static RAM.
// Address (addr) is constrained to the range (0, 63).
void MCP79412RTC::sramWrite(const uint8_t addr, const uint8_t value)
{
    writeRTC( (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(const uint8_t addr, const uint8_t* values, const uint8_t 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
        writeRTC( (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).
uint8_t MCP79412RTC::sramRead(const uint8_t addr)
{
    uint8_t value;

    readRTC( (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(const uint8_t addr, uint8_t* values, const uint8_t 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
        readRTC((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(const uint8_t addr, const uint8_t 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(const uint8_t addr, const uint8_t* values, const uint8_t nBytes)
{
    if (nBytes >= 1 && nBytes <= EEPROM_PAGE_SIZE) {
        i2cBeginTransmission(EEPROM_ADDR);
        i2cWrite( addr & ~(EEPROM_PAGE_SIZE - 1) & (EEPROM_SIZE - 1) );
        for (uint8_t 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).
uint8_t MCP79412RTC::eepromRead(const uint8_t addr)
{
    uint8_t 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(const uint8_t addr, uint8_t* values, const uint8_t 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(EEPROM_ADDR, nBytes);
        for (uint8_t i=0; i<nBytes; i++) values[i] = i2cRead();
    }
}

// Wait for EEPROM write to complete.
uint8_t MCP79412RTC::eepromWait()
{
    uint8_t waitCount{0};
    uint8_t txStatus;

    do {
        ++waitCount;
        i2cBeginTransmission(EEPROM_ADDR);
        i2cWrite(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.
int16_t MCP79412RTC::calibRead()
{
    uint8_t val {readRTC(OSCTRIM)};

    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(const int16_t value)
{
    if (value >= -127 && value <= 127) {
        uint8_t calibVal = abs(value);
        if (value < 0) calibVal += 128;
        writeRTC(OSCTRIM, 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(uint8_t* uniqueID)
{
    i2cBeginTransmission(EEPROM_ADDR);
    i2cWrite(UNIQUE_ID_ADDR);
    i2cEndTransmission();
    i2cRequestFrom( EEPROM_ADDR, UNIQUE_ID_SIZE );
    for (uint8_t 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(uint8_t* uniqueID)
{
    uint8_t 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 (uint8_t 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 PWRFAIL 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)
{
    uint8_t day, yr;                // copies of the RTC Day and Year registers
    readRTC(RTCWKDAY, &day, 1);
    readRTC(RTCYEAR, &yr, 1);
    yr = y2kYearToTm(bcd2dec(yr));
    if ( day & _BV(PWRFAIL) ) {
        i2cBeginTransmission(RTC_ADDR);
        i2cWrite(PWRDNMIN);
        i2cEndTransmission();

        i2cRequestFrom(RTC_ADDR, TIMESTAMP_SIZE);       // read both timestamp registers, 8 bytes total
        tmElements_t dn, up;                            // power down and power up times
        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 PWRFAIL 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(PWRFAIL);
        writeRTC(RTCWKDAY, &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(const SQWAVE_FREQS_t freq)
{
    uint8_t ctrlReg;
    readRTC(CONTROL, &ctrlReg, 1);
    if (freq > 3) {
        ctrlReg &= ~_BV(SQWEN);
    }
    else {
        ctrlReg = (ctrlReg & 0xF8) | _BV(SQWEN) | freq;
    }
    writeRTC(CONTROL, &ctrlReg, 1);
}

// Set an alarm to the given time_t value. Sets the alarm registers only,
// does not enable the alarm. See enableAlarm().
void MCP79412RTC::setAlarm(const ALARM_NBR_t alarmNumber, const time_t alarmTime)
{
    uint8_t day;                // need to preserve bits in the day (of week) register
    readRTC( ALM0WKDAY + alarmNumber * (ALM1SEC - ALM0SEC), &day, 1);
    tmElements_t tm;
    breakTime(alarmTime, tm);
    i2cBeginTransmission(RTC_ADDR);
    i2cWrite( ALM0SEC + alarmNumber * (ALM1SEC - ALM0SEC) );
    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();
}

// Set an alarm by specifying year, month, day, hour, minute, second.
// While the RTC does not use year for alarms, it's important to use the
// correct year to ensure the day of the week is calculated correctly. This
// is important especially if a day of week alarm will be used.
// Use a four-digit year, including century e.g. CCYY.
void MCP79412RTC::setAlarm(const ALARM_NBR_t alarmNumber, const uint16_t y, const uint8_t mon,
                  const uint8_t d, const uint8_t h, const uint8_t m, const uint8_t s)
{
    tmElements_t tm;
    tm.Year = CalendarYrToTm(y);
    tm.Month = mon;
    tm.Day = d;
    tm.Hour = h;
    tm.Minute = m;
    tm.Second = s;
    setAlarm(alarmNumber, makeTime(tm));
}

// 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(const ALARM_NBR_t alarmNumber, const ALARM_TYPES_t alarmType)
{
    uint8_t ctrl;               // control register has alarm enable bits
    readRTC(CONTROL, &ctrl, 1);
    if (alarmType < ALM_DISABLE) {
        uint8_t day;                            // alarm day register has config & flag bits
        readRTC(ALM0WKDAY + alarmNumber * (ALM1SEC - ALM0SEC), &day, 1);
        day = ( day & 0x87 ) | alarmType << 4;  // reset interrupt flag, OR in the config bits
        writeRTC(ALM0WKDAY + alarmNumber * (ALM1SEC - ALM0SEC), &day, 1);
        ctrl |= _BV(ALM0EN + alarmNumber);      // enable the alarm
    }
    else {
        ctrl &= ~(_BV(ALM0EN + alarmNumber));   // disable the alarm
    }
    writeRTC(CONTROL, &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(const ALARM_NBR_t alarmNumber)
{
    uint8_t day;                // alarm day register has config & flag bits
    readRTC( ALM0WKDAY + alarmNumber * (ALM1SEC - ALM0SEC), &day, 1);
    if (day & _BV(ALMxIF)) {
        day &= ~_BV(ALMxIF);    // turn off the alarm "interrupt" flag
        writeRTC( ALM0WKDAY + alarmNumber * (ALM1SEC - ALM0SEC), &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(const bool level)
{
    uint8_t ctrlReg;
    readRTC(CONTROL, &ctrlReg, 1);
    if (level)
        ctrlReg |= _BV(OUT);
    else
        ctrlReg &= ~_BV(OUT);
    writeRTC(CONTROL, &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(const bool polarity)
{
    uint8_t alm0Day;
    readRTC(ALM0WKDAY, &alm0Day, 1);
    if (polarity)
        alm0Day |= _BV(ALMPOL);
    else
        alm0Day &= ~_BV(ALMPOL);
    writeRTC(ALM0WKDAY, &alm0Day, 1);
}

// Check to see if the RTC's oscillator is started (STOSC bit in seconds
// register). Returns true if started.
bool MCP79412RTC::isRunning()
{
    i2cBeginTransmission(RTC_ADDR);
    i2cWrite(RTCSEC);
    i2cEndTransmission();

    // request just the seconds register
    i2cRequestFrom(RTC_ADDR, static_cast<uint8_t>(1));
    return i2cRead() & _BV(STOSC);
}

// 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(const bool enable)
{
    uint8_t day;
    readRTC(RTCWKDAY, &day, 1);
    if (enable)
        day |= _BV(VBATEN);
    else
        day &= ~_BV(VBATEN);

    writeRTC(RTCWKDAY, &day, 1);
    return;
}

// Decimal-to-BCD conversion
uint8_t MCP79412RTC::dec2bcd(const uint8_t n)
{
    return n + 6 * (n / 10);
}

// BCD-to-Decimal conversion
uint8_t __attribute__ ((noinline)) MCP79412RTC::bcd2dec(const uint8_t n)
{
    return n - 6 * (n >> 4);
}

// dump rtc registers, 16 bytes at a time.
// always dumps a multiple of 16 bytes.
// duplicate rows are suppressed and indicated with an asterisk.
void MCP79412RTC::dumpRegs(const uint32_t startAddr, const uint32_t nBytes)
{
    Serial.print(F("\nRTC REGISTERS\n"));
    uint32_t nRows = (nBytes + 15) >> 4;

    uint8_t d[16], last[16];
    uint32_t aLast {startAddr};
    for (uint32_t r = 0; r < nRows; r++) {
        uint32_t a = startAddr + 16 * r;
        readRTC(a, d, 16);
        bool same {true};
        for (int i=0; i<16; ++i) {
            if (last[i] != d[i]) same = false;
        }
        if (!same || r == 0 || r == nRows-1) {
            Serial.print(F("0x"));
            if ( a < 16 * 16 * 16 ) Serial.print('0');
            if ( a < 16 * 16 ) Serial.print('0');
            if ( a < 16 ) Serial.print('0');
            Serial.print(a, HEX);
            Serial.print(a == aLast+16 || r == 0 ? "  " : "* ");
            for ( int16_t c = 0; c < 16; c++ ) {
                if ( d[c] < 16 ) Serial.print('0');
                Serial.print(d[c], HEX);
                Serial.print(c == 7 ? "  " : " " );
            }
            Serial.println();
            aLast = a;
        }
        for (int i=0; i<16; ++i) {
            last[i] = d[i];
        }
    }
}

// dump rtc sram, 16 bytes at a time.
// always dumps a multiple of 16 bytes.
// duplicate rows are suppressed and indicated with an asterisk.
void MCP79412RTC::dumpSRAM(const uint32_t startAddr, const uint32_t nBytes)
{
    Serial.print(F("\nRTC SRAM\n"));
    uint32_t nRows = (nBytes + 15) >> 4;

    uint8_t d[16], last[16];
    uint32_t aLast {startAddr};
    for (uint32_t r = 0; r < nRows; r++) {
        uint32_t a = startAddr + 16 * r;
        sramRead(a, d, 16);
        bool same {true};
        for (int i=0; i<16; ++i) {
            if (last[i] != d[i]) same = false;
        }
        if (!same || r == 0 || r == nRows-1) {
            Serial.print(F("0x"));
            if ( a < 16 * 16 * 16 ) Serial.print('0');
            if ( a < 16 * 16 ) Serial.print('0');
            if ( a < 16 ) Serial.print('0');
            Serial.print(a, HEX);
            Serial.print(a == aLast+16 || r == 0 ? "  " : "* ");
            for ( int16_t c = 0; c < 16; c++ ) {
                if ( d[c] < 16 ) Serial.print('0');
                Serial.print(d[c], HEX);
                Serial.print(c == 7 ? "  " : " " );
            }
            Serial.println();
            aLast = a;
        }
        for (int i=0; i<16; ++i) {
            last[i] = d[i];
        }
    }
}

// dump rtc eeprom, 16 bytes at a time.
// always dumps a multiple of 16 bytes.
// duplicate rows are suppressed and indicated with an asterisk.
void MCP79412RTC::dumpEEPROM(const uint32_t startAddr, const uint32_t nBytes)
{
    Serial.print(F("\nRTC EEPROM\n"));
    uint32_t nRows = (nBytes + 15) >> 4;

    uint8_t d[16], last[16];
    uint32_t aLast {startAddr};
    for (uint32_t r = 0; r < nRows; r++) {
        uint32_t a = startAddr + 16 * r;
        eepromRead(a, d, 16);
        bool same {true};
        for (int i=0; i<16; ++i) {
            if (last[i] != d[i]) same = false;
        }
        if (!same || r == 0 || r == nRows-1) {
            Serial.print(F("0x"));
            if ( a < 16 * 16 * 16 ) Serial.print('0');
            if ( a < 16 * 16 ) Serial.print('0');
            if ( a < 16 ) Serial.print('0');
            Serial.print(a, HEX);
            Serial.print(a == aLast+16 || r == 0 ? "  " : "* ");
            for ( int16_t c = 0; c < 16; c++ ) {
                if ( d[c] < 16 ) Serial.print('0');
                Serial.print(d[c], HEX);
                Serial.print(c == 7 ? "  " : " " );
            }
            Serial.println();
            aLast = a;
        }
        for (int i=0; i<16; ++i) {
            last[i] = d[i];
        }
    }
}