Karl Zweimüller / RTC-MCP97410

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of RTC-DS1307 by Henry Leinen

Rtc_Mcp97410.cpp@11:ef48dcb888c9, 2015-01-16 (annotated)

Committer:
charly
Date:
Fri Jan 16 20:44:51 2015 +0000
Revision:
11:ef48dcb888c9
Parent:
10:780027029afe
Child:
12:88f82e47b6a1
added functions for EEPROM read/write and EUI-address(unlock, read write)

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 11:ef48dcb888c9 235 bool Rtc_Mcp97410::disableEEPROMWrite()
charly 11:ef48dcb888c9 236 {
charly 11:ef48dcb888c9 237 // protect all EEPROM from write operations
charly 11:ef48dcb888c9 238 // set STATUS_REGISTER 0xFF bits 2 and 3
charly 11:ef48dcb888c9 239 char reg = 0x0C;
charly 11:ef48dcb888c9 240 return write(ADDR_EEPROM, ADDR_EEPROM_SR,&reg, 1);
charly 11:ef48dcb888c9 241 }
charly 11:ef48dcb888c9 242
charly 11:ef48dcb888c9 243
charly 11:ef48dcb888c9 244 bool Rtc_Mcp97410::enableEEPROMWrite()
charly 11:ef48dcb888c9 245 {
charly 11:ef48dcb888c9 246 // enable all EEPROM write operations
charly 11:ef48dcb888c9 247 // unset STATUS_REGISTER 0xFF bits 2 and 3
charly 11:ef48dcb888c9 248 char reg = 0x00;
charly 11:ef48dcb888c9 249 return write(ADDR_EEPROM, ADDR_EEPROM_SR,&reg, 1);
charly 11:ef48dcb888c9 250 }
charly 11:ef48dcb888c9 251
charly 11:ef48dcb888c9 252 bool Rtc_Mcp97410::readEUI48(uint8_t* eui48)
charly 11:ef48dcb888c9 253 {
charly 11:ef48dcb888c9 254 //EUI48 start at EEPROM-address 0xF2
charly 11:ef48dcb888c9 255 return(readEEPROM(0xF2,(char *) eui48,6));
charly 11:ef48dcb888c9 256 }
charly 11:ef48dcb888c9 257
charly 11:ef48dcb888c9 258
charly 11:ef48dcb888c9 259 bool Rtc_Mcp97410::writeEUI48(uint8_t* eui48)
charly 11:ef48dcb888c9 260 {
charly 11:ef48dcb888c9 261 //EUI48 start at EEPROM-address 0xF2
charly 11:ef48dcb888c9 262 return(writeEEPROM(0xF2,(char *) eui48,6));
charly 11:ef48dcb888c9 263 }
charly 11:ef48dcb888c9 264
charly 11:ef48dcb888c9 265 bool Rtc_Mcp97410::unlockEUI()
charly 11:ef48dcb888c9 266 {
charly 11:ef48dcb888c9 267 // unlock the special EEPROM area
charly 11:ef48dcb888c9 268 // write 0x55 and then 0xAA to the EEUNLOCK-register
charly 11:ef48dcb888c9 269 char reg =0x00;
charly 11:ef48dcb888c9 270 bool result = true;
charly 11:ef48dcb888c9 271
charly 11:ef48dcb888c9 272 reg = 0x55;
charly 11:ef48dcb888c9 273 result &= writeRTC(ADDR_ULID,&reg,1);
charly 11:ef48dcb888c9 274 reg = 0xAA;
charly 11:ef48dcb888c9 275 result &= writeRTC(ADDR_ULID,&reg,1);
charly 11:ef48dcb888c9 276 if (result) {
charly 11:ef48dcb888c9 277 INFO("Successfully UNLOCKED the EUI-Area in EEPROM\n");
charly 11:ef48dcb888c9 278 return true;
charly 11:ef48dcb888c9 279 } else {
charly 11:ef48dcb888c9 280 ERR("Error in UNLOCKING the EUI-Area in EEPROM\n");
charly 11:ef48dcb888c9 281 return false;
charly 11:ef48dcb888c9 282 }
charly 11:ef48dcb888c9 283 }
leihen 7:dca20be3ef38 284
charly 10:780027029afe 285 RtcCls::RtcCls(I2C* i2c, PinName sqw, bool bUseSqw)
charly 10:780027029afe 286 : Rtc_Mcp97410(i2c), m_sqw(sqw), m_bUseSqw(bUseSqw), m_bAlarmEnabled(false), m_alarmfunc(NULL)
leihen 7:dca20be3ef38 287 {
leihen 9:5627b407e097 288 Time_rtc t;
leihen 9:5627b407e097 289 // query time from device
leihen 9:5627b407e097 290 getTime(t);
leihen 9:5627b407e097 291 // sync the time with MBED RTC
leihen 9:5627b407e097 292 struct tm now = {t.sec, t.min, t.hour, t.date, t.mon-1, t.year-1900};
leihen 9:5627b407e097 293 m_time = mktime(&now);
leihen 9:5627b407e097 294 set_time(m_time);
charly 11:ef48dcb888c9 295
leihen 7:dca20be3ef38 296 // Only register the callback and start the SQW if requested to do so. Otherwise the system
leihen 7:dca20be3ef38 297 // will use the MBED built-in RTC.
leihen 7:dca20be3ef38 298 if (m_bUseSqw) {
leihen 7:dca20be3ef38 299 // start the wave
leihen 7:dca20be3ef38 300 setSquareWaveOutput(true, RS1Hz);
leihen 7:dca20be3ef38 301 // register callback from now on the time will be maintained by the square wave input
leihen 7:dca20be3ef38 302 m_sqw.rise(this, &RtcCls::_callback);
leihen 7:dca20be3ef38 303 }
leihen 7:dca20be3ef38 304 }
leihen 7:dca20be3ef38 305
leihen 7:dca20be3ef38 306 void RtcCls::_callback(void)
leihen 7:dca20be3ef38 307 {
leihen 8:d0e66fa78e79 308 // INFO("Tick!");
leihen 7:dca20be3ef38 309 // Simply increase the number of seconds
leihen 7:dca20be3ef38 310 m_time++;
leihen 8:d0e66fa78e79 311 // if (m_bAlarmEnabled && (m_time == m_alarmTime)) {
leihen 8:d0e66fa78e79 312 // if (m_alarmfunc != NULL)
leihen 8:d0e66fa78e79 313 // m_alarmfunc();
leihen 8:d0e66fa78e79 314 // m_bAlarmEnabled = false;
leihen 8:d0e66fa78e79 315 // }
leihen 7:dca20be3ef38 316 }
leihen 7:dca20be3ef38 317
leihen 7:dca20be3ef38 318 time_t RtcCls::getTime()
leihen 7:dca20be3ef38 319 {
leihen 7:dca20be3ef38 320 // 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 321 if (!m_bUseSqw) {
leihen 7:dca20be3ef38 322 Time_rtc t;
leihen 7:dca20be3ef38 323 getTime(t);
leihen 8:d0e66fa78e79 324 struct tm now = {t.sec, t.min, t.hour, t.date, t.mon-1, t.year-1900};
leihen 7:dca20be3ef38 325 m_time = mktime(&now);
leihen 8:d0e66fa78e79 326 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 327 } else {
leihen 8:d0e66fa78e79 328 INFO("getting time Ticks=%08lx", m_time);
leihen 7:dca20be3ef38 329 }
leihen 7:dca20be3ef38 330 return m_time;
leihen 7:dca20be3ef38 331 }
leihen 7:dca20be3ef38 332
leihen 7:dca20be3ef38 333 void RtcCls::setTime(time_t t)
leihen 7:dca20be3ef38 334 {
leihen 7:dca20be3ef38 335 Time_rtc tim;
leihen 7:dca20be3ef38 336 struct tm *now;
leihen 7:dca20be3ef38 337 now = localtime(&t);
leihen 7:dca20be3ef38 338
leihen 7:dca20be3ef38 339 tim.sec = now->tm_sec;
leihen 7:dca20be3ef38 340 tim.min = now->tm_min;
leihen 7:dca20be3ef38 341 tim.hour = now->tm_hour;
leihen 7:dca20be3ef38 342 tim.date = now->tm_mday;
leihen 8:d0e66fa78e79 343 tim.mon = now->tm_mon+1;
leihen 7:dca20be3ef38 344 tim.year = now->tm_year + 1900;
leihen 7:dca20be3ef38 345 tim.wday = now->tm_wday +1;
leihen 7:dca20be3ef38 346
leihen 7:dca20be3ef38 347 setTime( tim, true, true);
leihen 8:d0e66fa78e79 348 set_time(t);
leihen 7:dca20be3ef38 349 }