Karl Zweimüller / RTC-MCP97410

Library for Real Time Clock module MCP97410 based on Library for DS1307

Fork of RTC-DS1307 by Henry Leinen

Rtc_Mcp97410.cpp@13:10e564536e23, 2015-03-08 (annotated)

Committer:
charly
Date:
Sun Mar 08 21:12:29 2015 +0000
Revision:
13:10e564536e23
Parent:
12:88f82e47b6a1 
added Methods for reading and manipulating (inc/dec) the Calibration-Register of RTC

Who changed what in which revision?

UserRevisionLine numberNew contents of line
leihen 5:30531f2121a2 1 #include "mbed.h"
charly 10:780027029afe 2 #include "Rtc_Mcp97410.h"
leihen 7:dca20be3ef38 3
leihen 5:30531f2121a2 4 #ifndef DEBUG
charly 10:780027029afe 5 #define DEBUG
leihen 5:30531f2121a2 6 #endif
leihen 3:e89d63f3342e 7 #include "debug.h"
leihen 0:3940f0ad2ca5 8
charly 11:ef48dcb888c9 9 const char *Rtc_Mcp97410::m_weekDays[] = { "Saturday", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" };
leihen 0:3940f0ad2ca5 10
leihen 0:3940f0ad2ca5 11
charly 10:780027029afe 12 Rtc_Mcp97410::Rtc_Mcp97410(I2C* i2c)
leihen 0:3940f0ad2ca5 13 {
charly 11:ef48dcb888c9 14
charly 11:ef48dcb888c9 15 _i2c = i2c;
charly 11:ef48dcb888c9 16 if (_i2c == NULL)
charly 10:780027029afe 17 error("Rtc_Mcp97410: no I2C specified");
charly 11:ef48dcb888c9 18
leihen 1:64274190e842 19 // Set the frequency to standard 100kHz
charly 10:780027029afe 20 // MCP97410 can handle full 400kHz-speed!
charly 11:ef48dcb888c9 21 //_i2c->frequency(100000);
leihen 0:3940f0ad2ca5 22 }
leihen 0:3940f0ad2ca5 23
charly 10:780027029afe 24 Rtc_Mcp97410::~Rtc_Mcp97410()
leihen 0:3940f0ad2ca5 25 {
charly 11:ef48dcb888c9 26
leihen 0:3940f0ad2ca5 27 }
leihen 0:3940f0ad2ca5 28
charly 10:780027029afe 29 bool Rtc_Mcp97410::setTime(Time_rtc& time, bool start, bool thm)
leihen 0:3940f0ad2ca5 30 {
leihen 2:ee81f2c5a706 31 char buffer[7];
leihen 2:ee81f2c5a706 32 INFO("reading clock registers to write the new time : %d:%d:%d\n", time.hour, time.min, time.sec);
charly 11:ef48dcb888c9 33 if (!readRTC(ADDR_SEC,buffer,7)) {
leihen 2:ee81f2c5a706 34 ERR("Failed to read from RTC\n");
leihen 2:ee81f2c5a706 35 return false;
leihen 2:ee81f2c5a706 36 }
leihen 2:ee81f2c5a706 37 // Now update only the time part (saving the existing flags)
charly 11:ef48dcb888c9 38 if (start) {
charly 11:ef48dcb888c9 39 buffer[ADDR_SEC] |= START_32KHZ;
charly 11:ef48dcb888c9 40 } else {
charly 11:ef48dcb888c9 41 buffer[ADDR_SEC] &= ~START_32KHZ;
charly 11:ef48dcb888c9 42 }
charly 11:ef48dcb888c9 43 buffer[ADDR_SEC] = (buffer[ADDR_SEC]& START_32KHZ) | (decimalToBcd(time.sec)& ~START_32KHZ);
charly 11:ef48dcb888c9 44 buffer[ADDR_MIN] = decimalToBcd(time.min);
leihen 2:ee81f2c5a706 45 if (thm) {
leihen 2:ee81f2c5a706 46 // AM PM format
charly 11:ef48dcb888c9 47 buffer[ADDR_HOUR] = HOUR_12 | (time.hour>12 ? (0x20 | ((decimalToBcd(time.hour-12)))) : decimalToBcd(time.hour));
charly 11:ef48dcb888c9 48 } else {
charly 11:ef48dcb888c9 49 // 24 hours format: HOUR_12 is 0
charly 11:ef48dcb888c9 50 buffer[ADDR_HOUR] = decimalToBcd(time.hour) & 0x3F;
leihen 2:ee81f2c5a706 51 }
charly 10:780027029afe 52 // bit 3 of register 03 on MCP97410 is VBATEN (different to DS1307)!
charly 10:780027029afe 53 // should be set to 1 to enable Battery-Backup
charly 11:ef48dcb888c9 54 buffer[ADDR_DAY] = VBATEN | (time.wday & 0x07);
charly 11:ef48dcb888c9 55 buffer[ADDR_DATE] = decimalToBcd(time.date);
charly 11:ef48dcb888c9 56 buffer[ADDR_MNTH] = decimalToBcd(time.mon);
charly 11:ef48dcb888c9 57 buffer[ADDR_YEAR] = decimalToBcd(time.year-2000);
leihen 2:ee81f2c5a706 58 INFO("Writing new time and date data to RTC\n");
charly 11:ef48dcb888c9 59 if (!writeRTC(ADDR_SEC, buffer, 7) ) {
leihen 2:ee81f2c5a706 60 ERR("Failed to write the data to RTC!\n");
leihen 2:ee81f2c5a706 61 return false;
leihen 2:ee81f2c5a706 62 }
leihen 0:3940f0ad2ca5 63 return true;
leihen 0:3940f0ad2ca5 64 }
leihen 0:3940f0ad2ca5 65
charly 10:780027029afe 66 bool Rtc_Mcp97410::getTime(Time_rtc& time)
leihen 0:3940f0ad2ca5 67 {
leihen 1:64274190e842 68 char buffer[7];
leihen 1:64274190e842 69 bool thm = false;
charly 11:ef48dcb888c9 70
leihen 1:64274190e842 71 INFO("Getting time from RTC\n");
charly 11:ef48dcb888c9 72 if (!readRTC(ADDR_SEC, buffer, 7) ) {
leihen 1:64274190e842 73 // Failed to read
leihen 1:64274190e842 74 ERR("Failed to read from RTC\n");
leihen 1:64274190e842 75 return false;
leihen 1:64274190e842 76 }
charly 11:ef48dcb888c9 77 thm = ((buffer[ADDR_HOUR] & HOUR_12) == HOUR_12);
charly 11:ef48dcb888c9 78 time.sec = bcdToDecimal(buffer[ADDR_SEC]&0x7F);
charly 11:ef48dcb888c9 79 time.min = bcdToDecimal(buffer[ADDR_MIN]);
leihen 1:64274190e842 80 if (thm) {
leihen 1:64274190e842 81 // in 12-hour-mode, we need to add 12 hours if PM bit is set
charly 11:ef48dcb888c9 82 time.hour = Rtc_Mcp97410::bcdToDecimal( buffer[ADDR_HOUR] & 0x1F );
charly 11:ef48dcb888c9 83 if ((buffer[ADDR_HOUR] & PM) == PM)
leihen 1:64274190e842 84 time.hour += 12;
charly 11:ef48dcb888c9 85 } else {
charly 11:ef48dcb888c9 86 time.hour = Rtc_Mcp97410::bcdToDecimal( buffer[ADDR_HOUR] & 0x3F );
leihen 1:64274190e842 87 }
charly 11:ef48dcb888c9 88 time.wday = buffer[ADDR_DAY] & 0x07;
charly 11:ef48dcb888c9 89 INFO("OSCRUN:%0d PWRFAIL:%0d VBATEN:%0d\n", (buffer[ADDR_STAT]>>5) & 0x01, buffer[ADDR_STAT]>>4 & 0x01, buffer[ADDR_STAT]>>3 & 0x01);
charly 11:ef48dcb888c9 90 time.date = Rtc_Mcp97410::bcdToDecimal( buffer[ADDR_DATE]);
charly 11:ef48dcb888c9 91 time.mon = Rtc_Mcp97410::bcdToDecimal( buffer[ADDR_MNTH]);
charly 11:ef48dcb888c9 92 time.year = Rtc_Mcp97410::bcdToDecimal(buffer[ADDR_YEAR]) + 2000; // plus hundret is because RTC is giving the years since 2000, but std c struct tm needs years since 1900
charly 11:ef48dcb888c9 93
leihen 2:ee81f2c5a706 94 return true;
leihen 2:ee81f2c5a706 95 }
leihen 2:ee81f2c5a706 96
leihen 2:ee81f2c5a706 97
charly 10:780027029afe 98 bool Rtc_Mcp97410::startClock()
charly 10:780027029afe 99 {
charly 10:780027029afe 100 char strtStop;
charly 11:ef48dcb888c9 101
charly 10:780027029afe 102 INFO ("Reading clock start/stop register value\n");
charly 11:ef48dcb888c9 103 if (!readRTC(ADDR_SEC, &strtStop, 1)) {
charly 10:780027029afe 104 ERR("Failed to read clock start stop register !\n");
charly 10:780027029afe 105 return false;
charly 10:780027029afe 106 }
charly 11:ef48dcb888c9 107 //set bit
charly 11:ef48dcb888c9 108 strtStop |= START_32KHZ;
charly 11:ef48dcb888c9 109
charly 11:ef48dcb888c9 110
charly 10:780027029afe 111 INFO("Writing back start/stop register value\n");
charly 11:ef48dcb888c9 112 if (!writeRTC(ADDR_SEC, &strtStop, 1)) {
charly 10:780027029afe 113 ERR("Failed to write the start stop register !\n");
charly 10:780027029afe 114 return false;
charly 10:780027029afe 115 }
charly 11:ef48dcb888c9 116
charly 10:780027029afe 117 INFO("Start/stop register value successfully written\n");
charly 10:780027029afe 118 return true;
charly 10:780027029afe 119 }
charly 10:780027029afe 120
charly 10:780027029afe 121 bool Rtc_Mcp97410::stopClock()
leihen 2:ee81f2c5a706 122 {
leihen 2:ee81f2c5a706 123 char strtStop;
charly 11:ef48dcb888c9 124
leihen 2:ee81f2c5a706 125 INFO ("Reading clock start/stop register value\n");
charly 11:ef48dcb888c9 126 if (!readRTC(ADDR_SEC, &strtStop, 1)) {
leihen 2:ee81f2c5a706 127 ERR("Failed to read clock start stop register !\n");
leihen 2:ee81f2c5a706 128 return false;
leihen 2:ee81f2c5a706 129 }
charly 11:ef48dcb888c9 130 //clear bit
charly 11:ef48dcb888c9 131 strtStop &= ~START_32KHZ;
charly 11:ef48dcb888c9 132
leihen 2:ee81f2c5a706 133 INFO("Writing back start/stop register value\n");
charly 11:ef48dcb888c9 134 if (!writeRTC(ADDR_SEC, &strtStop, 1)) {
leihen 2:ee81f2c5a706 135 ERR("Failed to write the start stop register !\n");
leihen 2:ee81f2c5a706 136 return false;
leihen 2:ee81f2c5a706 137 }
charly 11:ef48dcb888c9 138
leihen 2:ee81f2c5a706 139 INFO("Start/stop register value successfully written\n");
leihen 2:ee81f2c5a706 140 return true;
leihen 2:ee81f2c5a706 141 }
leihen 2:ee81f2c5a706 142
charly 10:780027029afe 143 bool Rtc_Mcp97410::setSquareWaveOutput(bool ena, SqwRateSelect_t rs)
leihen 2:ee81f2c5a706 144 {
leihen 2:ee81f2c5a706 145 char reg;
leihen 2:ee81f2c5a706 146 INFO("Reading register value first\n");
charly 11:ef48dcb888c9 147
charly 11:ef48dcb888c9 148 if (!readRTC(ADDR_CTRL,&reg, 1)) {
charly 11:ef48dcb888c9 149 ERR("Failed to read RTC register value !\n");
leihen 2:ee81f2c5a706 150 return false;
leihen 2:ee81f2c5a706 151 }
charly 11:ef48dcb888c9 152 INFO("[Reg:0x07] = %02x\n", reg);
charly 11:ef48dcb888c9 153
leihen 2:ee81f2c5a706 154 // preserve the OUT control bit while writing the frequency and enable bits
charly 11:ef48dcb888c9 155 reg = (reg & OUT_PIN) | (ena ? 0x10 : 0) | ((char)rs & 0x03);
leihen 2:ee81f2c5a706 156
leihen 2:ee81f2c5a706 157 INFO("Writing back register value\n");
charly 11:ef48dcb888c9 158 INFO("[Reg:0x07] = %02x\n", reg);
charly 11:ef48dcb888c9 159
charly 11:ef48dcb888c9 160 if (!writeRTC(ADDR_CTRL, &reg, 1)) {
leihen 2:ee81f2c5a706 161 ERR("Failed to write register value !\n");
leihen 2:ee81f2c5a706 162 return false;
leihen 2:ee81f2c5a706 163 }
charly 11:ef48dcb888c9 164
leihen 2:ee81f2c5a706 165 INFO("Successfully changed the square wave output.\n");
leihen 2:ee81f2c5a706 166 return true;
leihen 2:ee81f2c5a706 167 }
leihen 2:ee81f2c5a706 168
leihen 2:ee81f2c5a706 169
leihen 1:64274190e842 170
charly 11:ef48dcb888c9 171 bool Rtc_Mcp97410::read(int control_byte, int address, char *buffer, int len)
leihen 1:64274190e842 172 {
leihen 1:64274190e842 173 char buffer2[2] = {(char)address, 0};
charly 11:ef48dcb888c9 174
charly 11:ef48dcb888c9 175 // _i2c->start();
charly 11:ef48dcb888c9 176 if (_i2c->write(control_byte, buffer2, 1) != 0) {
charly 11:ef48dcb888c9 177 ERR("Failed to write register address on RTC or EEPROM!\n");
charly 11:ef48dcb888c9 178 _i2c->stop();
leihen 1:64274190e842 179 return false;
leihen 1:64274190e842 180 }
charly 11:ef48dcb888c9 181 if (_i2c->read(control_byte, buffer, len) != 0) {
leihen 1:64274190e842 182 ERR("Failed to read register !\n");
leihen 1:64274190e842 183 return false;
leihen 1:64274190e842 184 }
charly 11:ef48dcb888c9 185 _i2c->stop();
charly 11:ef48dcb888c9 186
charly 11:ef48dcb888c9 187 INFO("Successfully read %d bytes from RTC or EEPROM\n", len);
leihen 1:64274190e842 188 return true;
leihen 1:64274190e842 189 }
leihen 1:64274190e842 190
charly 11:ef48dcb888c9 191 bool Rtc_Mcp97410::readRTC(int address, char *buffer, int len)
charly 11:ef48dcb888c9 192 {
charly 11:ef48dcb888c9 193 return read(ADDR_RTCC, address,buffer, len);
charly 11:ef48dcb888c9 194 }
charly 11:ef48dcb888c9 195
charly 11:ef48dcb888c9 196 bool Rtc_Mcp97410::readEEPROM(int address, char *buffer, int len)
charly 11:ef48dcb888c9 197 {
charly 11:ef48dcb888c9 198 return read(ADDR_EEPROM, address,buffer, len);
charly 11:ef48dcb888c9 199 }
charly 11:ef48dcb888c9 200
charly 11:ef48dcb888c9 201 bool Rtc_Mcp97410::write(int control_byte, int address, char *buffer, int len)
leihen 1:64274190e842 202 {
leihen 1:64274190e842 203 char buffer2[10];
leihen 1:64274190e842 204 buffer2[0] = address&0xFF;
leihen 1:64274190e842 205 for (int i = 0 ; i < len ; i++)
leihen 1:64274190e842 206 buffer2[i+1] = buffer[i];
leihen 1:64274190e842 207
charly 11:ef48dcb888c9 208 // _i2c->start();
charly 11:ef48dcb888c9 209 if (_i2c->write(control_byte, buffer2, len+1) != 0) {
charly 11:ef48dcb888c9 210 ERR("Failed to write data to rtc or EEPROM\n");
charly 11:ef48dcb888c9 211 _i2c->stop();
leihen 1:64274190e842 212 return false;
leihen 1:64274190e842 213 }
charly 11:ef48dcb888c9 214 _i2c->stop();
charly 11:ef48dcb888c9 215 INFO("Successfully written %d bytes to RTC or EEPROM\n", len);
leihen 1:64274190e842 216 return true;
leihen 7:dca20be3ef38 217 }
leihen 7:dca20be3ef38 218
leihen 7:dca20be3ef38 219
charly 11:ef48dcb888c9 220 bool Rtc_Mcp97410::writeRTC(int address, char *buffer, int len)
charly 11:ef48dcb888c9 221 {
charly 11:ef48dcb888c9 222 return write(ADDR_RTCC, address,buffer, len);
charly 11:ef48dcb888c9 223 }
leihen 7:dca20be3ef38 224
charly 11:ef48dcb888c9 225 bool Rtc_Mcp97410::writeEEPROM(int address, char* buffer, int len)
charly 11:ef48dcb888c9 226 {
charly 11:ef48dcb888c9 227 if (len <=8) {
charly 11:ef48dcb888c9 228 return write(ADDR_EEPROM, address,buffer, len);
charly 11:ef48dcb888c9 229 } else {
charly 11:ef48dcb888c9 230 ERR("Can write maximum 8 Bytes to EEPROM in one call\n");
charly 11:ef48dcb888c9 231 return false;
charly 11:ef48dcb888c9 232 }
charly 11:ef48dcb888c9 233 }
charly 11:ef48dcb888c9 234
charly 13:10e564536e23 235
charly 13:10e564536e23 236 uint8_t Rtc_Mcp97410::readTrim()
charly 13:10e564536e23 237 {
charly 13:10e564536e23 238 uint8_t trim;
charly 13:10e564536e23 239 if (readRTC(ADDR_CAL, (char *) &trim, 1)) {
charly 13:10e564536e23 240 INFO("OSCTRIM: %02X \n", trim);
charly 13:10e564536e23 241 return trim;
charly 13:10e564536e23 242 } else {
charly 13:10e564536e23 243 return 0;
charly 13:10e564536e23 244 }
charly 13:10e564536e23 245 }
charly 13:10e564536e23 246
charly 13:10e564536e23 247 bool Rtc_Mcp97410::incTrim()
charly 13:10e564536e23 248 {
charly 13:10e564536e23 249 uint8_t trim;
charly 13:10e564536e23 250 uint8_t trim_val;
charly 13:10e564536e23 251 uint8_t trim_sign;
charly 13:10e564536e23 252
charly 13:10e564536e23 253 readRTC(ADDR_CAL, (char *) &trim, 1);
charly 13:10e564536e23 254 trim_val = 0x7F&trim;
charly 13:10e564536e23 255 trim_sign= trim >> 7;
charly 13:10e564536e23 256 if (trim_sign == 1) {
charly 13:10e564536e23 257 // positive: inc
charly 13:10e564536e23 258 if (trim_val < 0x7F) {
charly 13:10e564536e23 259 trim_val = trim_val++;
charly 13:10e564536e23 260 }
charly 13:10e564536e23 261 } else {
charly 13:10e564536e23 262 // negative: dec
charly 13:10e564536e23 263 if (trim_val != 0) {
charly 13:10e564536e23 264 trim_val = trim_val--;
charly 13:10e564536e23 265 } else {
charly 13:10e564536e23 266 // change sign
charly 13:10e564536e23 267 trim_sign = 1;
charly 13:10e564536e23 268 }
charly 13:10e564536e23 269 }
charly 13:10e564536e23 270 trim = trim_sign <<7 | trim_val;
charly 13:10e564536e23 271 INFO("incTrim: New TRIM: %02X\n", trim);
charly 13:10e564536e23 272 return writeRTC(ADDR_CAL, (char *) &trim, 1);
charly 13:10e564536e23 273 }
charly 13:10e564536e23 274
charly 13:10e564536e23 275 bool Rtc_Mcp97410::decTrim()
charly 13:10e564536e23 276 {
charly 13:10e564536e23 277 uint8_t trim;
charly 13:10e564536e23 278 uint8_t trim_val;
charly 13:10e564536e23 279 uint8_t trim_sign;
charly 13:10e564536e23 280
charly 13:10e564536e23 281 readRTC(ADDR_CAL, (char *) &trim, 1);
charly 13:10e564536e23 282 trim_val = 0x7F&trim;
charly 13:10e564536e23 283 trim_sign= trim >> 7;
charly 13:10e564536e23 284 if (trim_sign == 0) {
charly 13:10e564536e23 285 // negative: inc
charly 13:10e564536e23 286 if (trim_val < 0x7F) {
charly 13:10e564536e23 287 trim_val = trim_val++;
charly 13:10e564536e23 288 }
charly 13:10e564536e23 289 } else {
charly 13:10e564536e23 290 // positive: dec
charly 13:10e564536e23 291 if (trim_val != 0) {
charly 13:10e564536e23 292 trim_val = trim_val--;
charly 13:10e564536e23 293 } else {
charly 13:10e564536e23 294 // change sign
charly 13:10e564536e23 295 trim_sign = 0;
charly 13:10e564536e23 296 }
charly 13:10e564536e23 297 }
charly 13:10e564536e23 298 trim = trim_sign <<7 | trim_val;
charly 13:10e564536e23 299 INFO("decTrim: New TRIM: %02X\n", trim);
charly 13:10e564536e23 300 return writeRTC(ADDR_CAL, (char *) &trim, 1);
charly 13:10e564536e23 301 }
charly 13:10e564536e23 302
charly 11:ef48dcb888c9 303 bool Rtc_Mcp97410::disableEEPROMWrite()
charly 11:ef48dcb888c9 304 {
charly 11:ef48dcb888c9 305 // protect all EEPROM from write operations
charly 11:ef48dcb888c9 306 // set STATUS_REGISTER 0xFF bits 2 and 3
charly 11:ef48dcb888c9 307 char reg = 0x0C;
charly 11:ef48dcb888c9 308 return write(ADDR_EEPROM, ADDR_EEPROM_SR,&reg, 1);
charly 11:ef48dcb888c9 309 }
charly 11:ef48dcb888c9 310
charly 11:ef48dcb888c9 311
charly 11:ef48dcb888c9 312 bool Rtc_Mcp97410::enableEEPROMWrite()
charly 11:ef48dcb888c9 313 {
charly 11:ef48dcb888c9 314 // enable all EEPROM write operations
charly 11:ef48dcb888c9 315 // unset STATUS_REGISTER 0xFF bits 2 and 3
charly 11:ef48dcb888c9 316 char reg = 0x00;
charly 11:ef48dcb888c9 317 return write(ADDR_EEPROM, ADDR_EEPROM_SR,&reg, 1);
charly 11:ef48dcb888c9 318 }
charly 11:ef48dcb888c9 319
charly 11:ef48dcb888c9 320 bool Rtc_Mcp97410::readEUI48(uint8_t* eui48)
charly 11:ef48dcb888c9 321 {
charly 11:ef48dcb888c9 322 //EUI48 start at EEPROM-address 0xF2
charly 11:ef48dcb888c9 323 return(readEEPROM(0xF2,(char *) eui48,6));
charly 11:ef48dcb888c9 324 }
charly 11:ef48dcb888c9 325
charly 11:ef48dcb888c9 326 bool Rtc_Mcp97410::writeEUI48(uint8_t* eui48)
charly 11:ef48dcb888c9 327 {
charly 11:ef48dcb888c9 328 //EUI48 start at EEPROM-address 0xF2
charly 11:ef48dcb888c9 329 return(writeEEPROM(0xF2,(char *) eui48,6));
charly 11:ef48dcb888c9 330 }
charly 11:ef48dcb888c9 331
charly 12:88f82e47b6a1 332 bool Rtc_Mcp97410::readEUI64(uint8_t* eui64)
charly 12:88f82e47b6a1 333 {
charly 12:88f82e47b6a1 334 //EUI64 start at EEPROM-address 0xF2
charly 12:88f82e47b6a1 335 return(readEEPROM(0xF0,(char *) eui64,8));
charly 12:88f82e47b6a1 336 }
charly 12:88f82e47b6a1 337
charly 12:88f82e47b6a1 338
charly 12:88f82e47b6a1 339 bool Rtc_Mcp97410::writeEUI64(uint8_t* eui64)
charly 12:88f82e47b6a1 340 {
charly 12:88f82e47b6a1 341 //EUI64 start at EEPROM-address 0xF2
charly 12:88f82e47b6a1 342 return(writeEEPROM(0xF0,(char *) eui64,8));
charly 12:88f82e47b6a1 343 }
charly 12:88f82e47b6a1 344
charly 11:ef48dcb888c9 345 bool Rtc_Mcp97410::unlockEUI()
charly 11:ef48dcb888c9 346 {
charly 11:ef48dcb888c9 347 // unlock the special EEPROM area
charly 11:ef48dcb888c9 348 // write 0x55 and then 0xAA to the EEUNLOCK-register
charly 11:ef48dcb888c9 349 char reg =0x00;
charly 11:ef48dcb888c9 350 bool result = true;
charly 13:10e564536e23 351
charly 11:ef48dcb888c9 352 reg = 0x55;
charly 11:ef48dcb888c9 353 result &= writeRTC(ADDR_ULID,&reg,1);
charly 11:ef48dcb888c9 354 reg = 0xAA;
charly 11:ef48dcb888c9 355 result &= writeRTC(ADDR_ULID,&reg,1);
charly 11:ef48dcb888c9 356 if (result) {
charly 11:ef48dcb888c9 357 INFO("Successfully UNLOCKED the EUI-Area in EEPROM\n");
charly 11:ef48dcb888c9 358 return true;
charly 11:ef48dcb888c9 359 } else {
charly 11:ef48dcb888c9 360 ERR("Error in UNLOCKING the EUI-Area in EEPROM\n");
charly 11:ef48dcb888c9 361 return false;
charly 11:ef48dcb888c9 362 }
charly 11:ef48dcb888c9 363 }
leihen 7:dca20be3ef38 364
charly 10:780027029afe 365 RtcCls::RtcCls(I2C* i2c, PinName sqw, bool bUseSqw)
charly 10:780027029afe 366 : Rtc_Mcp97410(i2c), m_sqw(sqw), m_bUseSqw(bUseSqw), m_bAlarmEnabled(false), m_alarmfunc(NULL)
leihen 7:dca20be3ef38 367 {
leihen 9:5627b407e097 368 Time_rtc t;
leihen 9:5627b407e097 369 // query time from device
leihen 9:5627b407e097 370 getTime(t);
leihen 9:5627b407e097 371 // sync the time with MBED RTC
leihen 9:5627b407e097 372 struct tm now = {t.sec, t.min, t.hour, t.date, t.mon-1, t.year-1900};
leihen 9:5627b407e097 373 m_time = mktime(&now);
leihen 9:5627b407e097 374 set_time(m_time);
charly 11:ef48dcb888c9 375
leihen 7:dca20be3ef38 376 // Only register the callback and start the SQW if requested to do so. Otherwise the system
leihen 7:dca20be3ef38 377 // will use the MBED built-in RTC.
leihen 7:dca20be3ef38 378 if (m_bUseSqw) {
leihen 7:dca20be3ef38 379 // start the wave
leihen 7:dca20be3ef38 380 setSquareWaveOutput(true, RS1Hz);
leihen 7:dca20be3ef38 381 // register callback from now on the time will be maintained by the square wave input
leihen 7:dca20be3ef38 382 m_sqw.rise(this, &RtcCls::_callback);
leihen 7:dca20be3ef38 383 }
leihen 7:dca20be3ef38 384 }
leihen 7:dca20be3ef38 385
leihen 7:dca20be3ef38 386 void RtcCls::_callback(void)
leihen 7:dca20be3ef38 387 {
leihen 8:d0e66fa78e79 388 // INFO("Tick!");
leihen 7:dca20be3ef38 389 // Simply increase the number of seconds
leihen 7:dca20be3ef38 390 m_time++;
leihen 8:d0e66fa78e79 391 // if (m_bAlarmEnabled && (m_time == m_alarmTime)) {
leihen 8:d0e66fa78e79 392 // if (m_alarmfunc != NULL)
leihen 8:d0e66fa78e79 393 // m_alarmfunc();
leihen 8:d0e66fa78e79 394 // m_bAlarmEnabled = false;
leihen 8:d0e66fa78e79 395 // }
leihen 7:dca20be3ef38 396 }
leihen 7:dca20be3ef38 397
leihen 7:dca20be3ef38 398 time_t RtcCls::getTime()
leihen 7:dca20be3ef38 399 {
leihen 7:dca20be3ef38 400 // when not using the HW support, we have to query the RTC chip. Other wise we can just return out stored value
leihen 7:dca20be3ef38 401 if (!m_bUseSqw) {
leihen 7:dca20be3ef38 402 Time_rtc t;
leihen 7:dca20be3ef38 403 getTime(t);
leihen 8:d0e66fa78e79 404 struct tm now = {t.sec, t.min, t.hour, t.date, t.mon-1, t.year-1900};
leihen 7:dca20be3ef38 405 m_time = mktime(&now);
leihen 8:d0e66fa78e79 406 INFO("getting time %02d.%02d.%04d %02d:%02d:%02d Ticks=%08lx", t.date, t.mon, t.year, t.hour, t.min, t.sec, m_time);
charly 11:ef48dcb888c9 407 } else {
leihen 8:d0e66fa78e79 408 INFO("getting time Ticks=%08lx", m_time);
leihen 7:dca20be3ef38 409 }
leihen 7:dca20be3ef38 410 return m_time;
leihen 7:dca20be3ef38 411 }
leihen 7:dca20be3ef38 412
leihen 7:dca20be3ef38 413 void RtcCls::setTime(time_t t)
leihen 7:dca20be3ef38 414 {
leihen 7:dca20be3ef38 415 Time_rtc tim;
leihen 7:dca20be3ef38 416 struct tm *now;
leihen 7:dca20be3ef38 417 now = localtime(&t);
leihen 7:dca20be3ef38 418
leihen 7:dca20be3ef38 419 tim.sec = now->tm_sec;
leihen 7:dca20be3ef38 420 tim.min = now->tm_min;
leihen 7:dca20be3ef38 421 tim.hour = now->tm_hour;
leihen 7:dca20be3ef38 422 tim.date = now->tm_mday;
leihen 8:d0e66fa78e79 423 tim.mon = now->tm_mon+1;
leihen 7:dca20be3ef38 424 tim.year = now->tm_year + 1900;
leihen 7:dca20be3ef38 425 tim.wday = now->tm_wday +1;
leihen 7:dca20be3ef38 426
leihen 7:dca20be3ef38 427 setTime( tim, true, true);
leihen 8:d0e66fa78e79 428 set_time(t);
leihen 7:dca20be3ef38 429 }