Exemple #1
0
/*----------------------------------------------------------------------*
 * Set an alarm time. Sets the alarm registers only.  To cause the      *
 * INT pin to be asserted on alarm match, use alarmInterrupt().         *
 * This method can set either Alarm 1 or Alarm 2, depending on the      *
 * value of alarmType (use a value from the ALARM_TYPES_t enumeration). *
 * When setting Alarm 2, the seconds value must be supplied but is      *
 * ignored, recommend using zero. (Alarm 2 has no seconds register.)    *
 *----------------------------------------------------------------------*/
void DS3232RTC::setAlarm(ALARM_TYPES_t alarmType, byte seconds, byte minutes, byte hours, byte daydate)
{
    uint8_t addr;
    
    seconds = dec2bcd(seconds);
    minutes = dec2bcd(minutes);
    hours = dec2bcd(hours);
    daydate = dec2bcd(daydate);
    if (alarmType & 0x01) seconds |= _BV(A1M1);
    if (alarmType & 0x02) minutes |= _BV(A1M2);
    if (alarmType & 0x04) hours |= _BV(A1M3);
    if (alarmType & 0x10) hours |= _BV(DYDT);
    if (alarmType & 0x08) daydate |= _BV(A1M4);
    
    if ( !(alarmType & 0x80) ) {    //alarm 1
        addr = ALM1_SECONDS;
        writeRTC(addr++, seconds);
    }
    else {
        addr = ALM2_MINUTES;
    }
    writeRTC(addr++, minutes);
    writeRTC(addr++, hours);
    writeRTC(addr++, daydate);
}
Exemple #2
0
/*----------------------------------------------------------------------*
 * Returns the value of the oscillator stop flag (OSF) bit in the       *
 * control/status register which indicates that the oscillator is or    *
 * was stopped, and that the timekeeping data may be invalid.           *
 * Optionally clears the OSF bit depending on the argument passed.      *
 *----------------------------------------------------------------------*/
bool DS3232RTC::oscStopped(bool clearOSF)
{
    uint8_t s = readRTC(RTC_STATUS);    //read the status register
    bool ret = s & _BV(OSF);            //isolate the osc stop flag to return to caller
    if (ret && clearOSF) {              //clear OSF if it's set and the caller wants to clear it
        writeRTC( RTC_STATUS, s & ~_BV(OSF) );
    }
    return ret;
}
Exemple #3
0
/*----------------------------------------------------------------------*
 * Enable or disable an alarm "interrupt" which asserts the INT pin     *
 * on the RTC.                                                          *
 *----------------------------------------------------------------------*/
void DS3232RTC::alarmInterrupt(byte alarmNumber, boolean interruptEnabled)
{
    uint8_t controlReg, mask;
    
    controlReg = readRTC(RTC_CONTROL);
    mask = _BV(A1IE) << (alarmNumber - 1);
    if (interruptEnabled)
        controlReg |= mask;
    else
        controlReg &= ~mask;
    writeRTC(RTC_CONTROL, controlReg); 
}
Exemple #4
0
/*----------------------------------------------------------------------*
 * Enable or disable the square wave output.                            *
 * Use a value from the SQWAVE_FREQS_t enumeration for the parameter.   *
 *----------------------------------------------------------------------*/
void DS3232RTC::squareWave(SQWAVE_FREQS_t freq)
{
    uint8_t controlReg;

    controlReg = readRTC(RTC_CONTROL);
    if (freq >= SQWAVE_NONE) {
        controlReg |= _BV(INTCN);
    }
    else {
        controlReg = (controlReg & 0xE3) | (freq << RS1);
    }
    writeRTC(RTC_CONTROL, controlReg);
}
/*------------------------------------------------------*/
int			SetAlarm (void)
			{
			rtime	t = Time;
			int		i,j,k,n;
			char	s[8][8];

			for(i=0; i<8; ++i) {
				writeRTC(i,0);
				s[i][0] = 0;
                }
			n=sscanf(&LinkBuff[1],"%2d:%02d:%02d%s%s%s%s%s",
				&i,&j,&k,&s[0],&s[1],&s[2],&s[3],&s[4]);
			if(n>=3) {
					if(n==3) {
						t.hour=i;
						t.min=j;
						t.sec=k;
						AlarmEnable(&t);
						puts_pc("Wakeup on\r\n");
						}
					if(n>3)  {
						writeRTC(0,i);
						writeRTC(1,j);
						writeRTC(2,k);
						n -=3;
						for(i=0; n--; ++i)
							writeRTC(i+3,chrtx(s[i]));
						puts_pc("Submit on\r\n");
						}
					}
			else	{
					AlarmDisable();
					puts_pc("Wakeup off\r\n");
					}
            shutdown_save(NULL);
			return(null);
			}
Exemple #6
0
/*----------------------------------------------------------------------*
 * Returns true or false depending on whether the given alarm has been  *
 * triggered, and resets the alarm flag bit.                            *
 *----------------------------------------------------------------------*/
boolean DS3232RTC::alarm(byte alarmNumber)
{
    uint8_t statusReg, mask;
    
    statusReg = readRTC(RTC_STATUS);
    mask = _BV(A1F) << (alarmNumber - 1);
    if (statusReg & mask) {
        statusReg &= ~mask;
        writeRTC(RTC_STATUS, statusReg);
        return true;
    }
    else {
        return false;
    }
}
Exemple #7
0
/*----------------------------------------------------------------------*
 * Sets the RTC's time from a tmElements_t structure and clears the     *
 * oscillator stop flag (OSF) in the Control/Status register.           *
 * Returns the I2C status (zero if successful).                         *
 *----------------------------------------------------------------------*/
byte DS3232RTC::write(tmElements_t &tm)
{
    i2cBeginTransmission(RTC_ADDR);
    i2cWrite((uint8_t)RTC_SECONDS);
    i2cWrite(dec2bcd(tm.Second));
    i2cWrite(dec2bcd(tm.Minute));
    i2cWrite(dec2bcd(tm.Hour));         //sets 24 hour format (Bit 6 == 0)
    i2cWrite(tm.Wday);
    i2cWrite(dec2bcd(tm.Day));
    i2cWrite(dec2bcd(tm.Month));
    i2cWrite(dec2bcd(tmYearToY2k(tm.Year))); 
    byte ret = i2cEndTransmission();
    uint8_t s = readRTC(RTC_STATUS);        //read the status register
    writeRTC( RTC_STATUS, s & ~_BV(OSF) );  //clear the Oscillator Stop Flag
    return ret;
}
Exemple #8
0
//--------------------------------------------------------------------------------
// Sets time of RTC device and returns whether the operation was successful.
bool DS3232Controller::setDeviceTime(byte dayOfWeek, byte day, byte month,
		byte y2kYear, byte hour, byte minute, byte second) {
	Wire.beginTransmission(RTC_ADDR);
	Wire.write((uint8_t) RTC_SECONDS);
	Wire.write(dec2bcd(second));
	Wire.write(dec2bcd(minute));
	Wire.write(dec2bcd(hour));  //sets 24 hour format (Bit 6 == 0)
	Wire.write(dayOfWeek);
	Wire.write(dec2bcd(day));
	Wire.write(dec2bcd(month));
	Wire.write(dec2bcd(y2kYear + 30)); // convert Y2K year to year from 1970
	byte i2cStatus = Wire.endTransmission();

	uint8_t s = readRTC(RTC_STATUS);      //read the status register
	writeRTC(RTC_STATUS, s & ~_BV(OSF));  //clear the Oscillator Stop Flag

	readCurrentTimeFromDevice();	// sync time with device

	return (i2cStatus == 0);
}
Exemple #9
0
// --------------------------------------------------------
// Set the RTC's time from a tmElements_t structure.
// Returns the bus status (zero if successful).
uint8_t DS1302RTC::write(tmElements_t &tm)
{
  uint8_t buff[8];

  writeEN(true);

  if(!writeEN()) return 255;                // Error! Write-protect not disabled

  buff[0] = dec2bcd(tm.Second);             // Disable Clock halt flag
  buff[1] = dec2bcd(tm.Minute);
  buff[2] = dec2bcd(tm.Hour);               // 24-hour mode
  buff[3] = dec2bcd(tm.Day);
  buff[4] = dec2bcd(tm.Month);
  buff[5] = tm.Wday;
  buff[6] = dec2bcd(tmYearToY2k(tm.Year));
  buff[7] = B10000000;                      // Write protect enable

  writeRTC(buff);

  return writeEN();
}
Exemple #10
0
/*----------------------------------------------------------------------*
 * Write a single byte to RTC RAM.                                      *
 * Valid address range is 0x00 - 0xFF, no checking.                     *
 * Returns the I2C status (zero if successful).                         *
 *----------------------------------------------------------------------*/
byte DS3232RTC::writeRTC(byte addr, byte value)
{
    return ( writeRTC(addr, &value, 1) );
}
Exemple #11
0
// --------------------------------------------------------
// Set or clear Write-protect bit
// Before any write operation to the clock or RAM, must be 0.
// When 1, the write-protect bit prevents a write operation
// to any other register.
void DS1302RTC::writeEN(uint8_t value)
{
  uint8_t wp = readRTC(DS1302_ENABLE);
  bitWrite(wp, DS1302_WP, !value);
  writeRTC(DS1302_ENABLE, wp);
}
Exemple #12
0
// --------------------------------------------------------
// Set or clear Clock halt flag bit
// When this bit is set to logic 1, the clock oscillator
// is stopped and the DS1302 is placed into a low-power
// standby mode with a current drain of less than 100nA. When
// this bit is written to logic 0, the clock will start.
void DS1302RTC::haltRTC(uint8_t value)
{
  uint8_t seconds = readRTC(DS1302_SECONDS);
  bitWrite(seconds, DS1302_CH, value);
  writeRTC(DS1302_SECONDS, seconds);
}
Exemple #13
0
//--------------------------------------------------------------------------------
// Write a single byte to RTC RAM.
// Valid address range is 0x00 - 0xFF, no checking.
// Returns the I2C status (zero if successful).
byte DS3232Controller::writeRTC(byte addr, byte value) {
	return (writeRTC(addr, &value, 1));
}