// DS1302 RTC
// ----------
//
// By arduino.cc user "Krodal".
// June 2012
// Open Source / Public Domain
//
// Using Arduino 1.0.1
//
// Documentation: datasheet
//
//
// The DS1302 uses a 3-wire interface:
//    - bidirectional data.
//    - clock
//    - chip select
// It is not I2C, not OneWire, and not SPI.
// So the standard libraries can not be used.
// Even the shiftOut() function is not used, since it
// could be too fast (it might be slow enough,
// but that's not certain).
//
// I wrote my own interface code according to the datasheet.
// Any three pins of the Arduino can be used.
//   See the first defines below this comment,
//   to set your own pins.
//
// The "Chip Enable" pin was called "/Reset" before.
//
// The chip has internal pull-down registers.
// This keeps the chip disabled, even if the pins of
// the Arduino are floating.
//
//
// Range
// -----
//      seconds : 00-59
//      minutes : 00-59
//      hour    : 1-12 or 0-23
//      date    : 1-31
//      month   : 1-12
//      day     : 1-7
//      year    : 00-99
//
//
// Burst mode
// ----------
// In burst mode, all the clock data is read at once.
// This is to prevent a rollover of a digit during reading.
// The read data is from an internal buffer.
//
// The burst registers are commands, rather than addresses.
// Clock Data Read in Burst Mode
//    Start by writing 0xBF (as the address),
//    after that: read clock data
// Clock Data Write in Burst Mode
//    Start by writing 0xBE (as the address),
//    after that: write clock data
// Ram Data Read in Burst Mode
//    Start by writing 0xFF (as the address),
//    after that: read ram data
// Ram Data Write in Burst Mode
//    Start by writing 0xFE (as the address),
//    after that: write ram data
//
//
// Ram
// ---
// The DS1302 has 31 of ram, which can be used to store data.
// The contents will be lost if the Arduino is off,
// and the backup battery gets empty.
// It is better to store data in the EEPROM of the Arduino.
// The burst read or burst write for ram is not implemented
// in this code.
//
//
// Trickle charge
// --------------
// The DS1302 has a build-in trickle charger.
// That can be used for example with a lithium battery
// or a supercap.
// Using the trickle charger has not been implemented
// in this code.
//


// Set your own pins with these defines !
#define DS1302_SCLK 6    // Arduino pin for the Serial Clock
#define DS1302_IO   7    // Arduino pin for the Data I/O
#define DS1302_CE   8    // Arduino pin for the Chip Enable



// Register names.
// Since the highest bit is always '1',
// the registers start at 0x80
// If the register is read, the lowest bit should be '1'.
#define DS1302_SECONDS           0x80
#define DS1302_MINUTES           0x82
#define DS1302_HOURS             0x84
#define DS1302_DATE              0x86
#define DS1302_MONTH             0x88
#define DS1302_DAY               0x8A
#define DS1302_YEAR              0x8C
#define DS1302_ENABLE            0x8E
#define DS1302_TRICKLE           0x90
#define DS1302_CLOCK_BURST       0xBE
#define DS1302_CLOCK_BURST_WRITE 0xBE
#define DS1302_CLOCK_BURST_READ  0xBF
#define DS1302_RAMSTART          0xC0
#define DS1302_RAMEND            0xFC
#define DS1302_RAM_BURST         0xFE
#define DS1302_RAM_BURST_WRITE   0xFE
#define DS1302_RAM_BURST_READ    0xFF



// Defines for the bits, to be able to change
// between bit number and binary definition.
// By using the bit number, using the DS1302
// is like programming an AVR microcontroller.
// But instead of using "(1<<X)", or "_BV(X)",
// the Arduino "bit(X)" is used.
#define DS1302_D0 0
#define DS1302_D1 1
#define DS1302_D2 2
#define DS1302_D3 3
#define DS1302_D4 4
#define DS1302_D5 5
#define DS1302_D6 6
#define DS1302_D7 7


// Bit for reading (bit in address)
#define DS1302_READBIT DS1302_D0 // READBIT=1: read instruction

// Bit for clock (0) or ram (1) area,
// called R/C-bit (bit in address)
#define DS1302_RC DS1302_D6

// Seconds Register
#define DS1302_CH DS1302_D7   // 1 = Clock Halt, 0 = start

// Hour Register
#define DS1302_AM_PM DS1302_D5 // 0 = AM, 1 = PM
#define DS1302_12_24 DS1302 D7 // 0 = 24 hour, 1 = 12 hour

// Enable Register
#define DS1302_WP DS1302_D7   // 1 = Write Protect, 0 = enabled

// Trickle Register
#define DS1302_ROUT0 DS1302_D0
#define DS1302_ROUT1 DS1302_D1
#define DS1302_DS0   DS1302_D2
#define DS1302_DS1   DS1302_D2
#define DS1302_TCS0  DS1302_D4
#define DS1302_TCS1  DS1302_D5
#define DS1302_TCS2  DS1302_D6
#define DS1302_TCS3  DS1302_D7


// Structure for the first 8 registers.
// These 8 bytes can be read at once with
// the 'clock burst' command.
// Note that this structure contains an anonymous union.
// It might cause a problem on other compilers.
typedef struct ds1302_struct
{
uint8_t Seconds:
  4;      // low decimal digit 0-9
uint8_t Seconds10:
  3;    // high decimal digit 0-5
uint8_t CH:
  1;           // CH = Clock Halt
uint8_t Minutes:
  5;
uint8_t Minutes10:
  2;
uint8_t reserved1:
  1;
  union
  {
    struct
    {
uint8_t Hour:
      4;
uint8_t Hour10:
      1;
uint8_t reserved2:
      1;
uint8_t hour_12_24:
      1; // 0 for 24 hour format
    }
    h24;
    struct
    {
uint8_t Hour:
      4;
uint8_t Hour10:
      1;
uint8_t AM_PM:
      1;      // 0 for AM, 1 for PM
uint8_t reserved2:
      1;
uint8_t hour_12_24:
      1; // 1 for 12 hour format
    }
    h12;
  };
uint8_t Date:
  4;
uint8_t Date10:
  2;
uint8_t reserved3:
  2;
uint8_t Month:
  4;
uint8_t Month10:
  1;
uint8_t reserved4:
  3;
uint8_t Day:
  3;
uint8_t reserved5:
  5;
uint8_t Year:
  4;
uint8_t Year10:
  4;
uint8_t reserved6:
  7;
uint8_t WP:
  1;             // WP = Write Protect
};


void setup()
{
  ds1302_struct rtc;


  Serial.begin(9600);
  Serial.println(F("DS1302 Real Time Clock"));
  Serial.println(F("June 2012"));


  // Start by clearing the Write Protect bit
  // Otherwise the clock data cannot be written
  // The whole register is written,
  // but the WP-bit is the only bit in that register.
  DS1302_write (DS1302_ENABLE, 0);

  // Disable Trickle Charger.
  DS1302_write (DS1302_TRICKLE, 0x00);

  // Remove the next define,
  // after the right date and time are set.
#define SET_DATE_TIME_JUST_ONCE
#ifdef SET_DATE_TIME_JUST_ONCE
  // Set a time and date
  // This also clears the CH (Clock Halt) bit,
  // to start the clock.

  // Fill the structure with zeros to make
  // any unused bits zero
  memset ((char *) &rtc, 0, sizeof(rtc));

  rtc.Seconds = 0;
  rtc.Seconds10 = 0;
  rtc.CH = 0;        // 1 for Clock Halt, 0 to run;
  rtc.Minutes = 0;
  rtc.Minutes10 = 0;
  rtc.h24.Hour = 0;
  rtc.h24.Hour10 = 0;
  rtc.h24.hour_12_24 = 0; // 0 for 24 hour format
  rtc.Date = 0;
  rtc.Date10 = 0;
  rtc.Month = 0;
  rtc.Month10 = 0;
  rtc.Day = 0;
  rtc.Year = 0;
  rtc.Year10 = 0;
  rtc.WP = 0;

  // Write all clock data at once (burst mode).
  DS1302_clock_burst_write( (uint8_t *) &rtc);
#endif


//interrupt voor knop
pinMode(2, INPUT);
attachInterrupt(0, uurErbij, FALLING);

}


void loop()
{
  ds1302_struct rtc;
  char buffer[80];     // the code uses 70 characters.

  // Read all clock data at once (burst mode).
  DS1302_clock_burst_read( (uint8_t *) &rtc);

  sprintf(buffer, "Time = %02d:%02d:%02d, ", \
    (rtc.h24.Hour10 * 10) + rtc.h24.Hour, \
    (rtc.Minutes10 * 10) + rtc.Minutes, \
    (rtc.Seconds10 * 10) + rtc.Seconds);
  Serial.print(buffer);

  sprintf(buffer, "Date(day of month) = %d, Month = %d, " \
    "Day(day of week) = %d, Year = %d", \
    (rtc.Date10 * 10) + rtc.Date, \
    (rtc.Month10 * 10) + rtc.Month, \
    rtc.Day, \
    2000 + (rtc.Year10 * 10) + rtc.Year);
  Serial.println(buffer);

  delay(5000);
}


// --------------------------------------------------------
// DS1302_clock_burst_read
//
// This function reads 8 bytes clock data in burst mode
// from the DS1302.
//
// This function may be called as the first function,
// also the pinMode is set.
//
void DS1302_clock_burst_read( uint8_t *p)
{
  int i;

  _DS1302_start();

  // Instead of the address,
  // the CLOCK_BURST_READ command is issued
  // the I/O-line is released for the data
  _DS1302_togglewrite( DS1302_CLOCK_BURST_READ, true);

  for (i=0; i<8; i++)
  {
    *p++ = _DS1302_toggleread();
  }
  _DS1302_stop();
}


// --------------------------------------------------------
// DS1302_clock_burst_write
//
// This function writes 8 bytes clock data in burst mode
// to the DS1302.
//
// This function may be called as the first function,
// also the pinMode is set.
//
void DS1302_clock_burst_write( uint8_t *p)
{
  int i;

  _DS1302_start();

  // Instead of the address,
  // the CLOCK_BURST_WRITE command is issued.
  // the I/O-line is not released
  _DS1302_togglewrite( DS1302_CLOCK_BURST_WRITE, false);

  for (i=0; i<8; i++)
  {
    // the I/O-line is not released
    _DS1302_togglewrite( *p++, false);
  }
  _DS1302_stop();
}


// --------------------------------------------------------
// DS1302_read
//
// This function reads a byte from the DS1302
// (clock or ram).
//
// The address could be like "0x80" or "0x81",
// the lowest bit is set anyway.
//
// This function may be called as the first function,
// also the pinMode is set.
//
uint8_t DS1302_read(int address)
{
  uint8_t data;

  // set lowest bit (read bit) in address
  bitSet (address, DS1302_READBIT);

  _DS1302_start();
  // the I/O-line is released for the data
  _DS1302_togglewrite (address, true);
  data = _DS1302_toggleread ();
  _DS1302_stop();

  return (data);
}


// --------------------------------------------------------
// DS1302_write
//
// This function writes a byte to the DS1302 (clock or ram).
//
// The address could be like "0x80" or "0x81",
// the lowest bit is cleared anyway.
//
// This function may be called as the first function,
// also the pinMode is set.
//
void DS1302_write(int address, uint8_t data)
{
  // clear lowest bit (read bit) in address
  bitClear (address, DS1302_READBIT);

  _DS1302_start();
  // don't release the I/O-line
  _DS1302_togglewrite (address, false);
  // don't release the I/O-line
  _DS1302_togglewrite (data, false);
  _DS1302_stop();
}


// --------------------------------------------------------
// _DS1302_start
//
// A helper function to setup the start condition.
//
// I don't use an 'init' function.
// But now the pinMode is set every time.
// That's not a big deal, and it's valid.
void _DS1302_start(void)
{
  digitalWrite (DS1302_CE, LOW); // default, not enabled
  pinMode (DS1302_CE, OUTPUT);

  digitalWrite (DS1302_SCLK, LOW); // default, clock low
  pinMode (DS1302_SCLK, OUTPUT);

  pinMode (DS1302_IO, OUTPUT);

  digitalWrite (DS1302_CE, HIGH); // start the session
  delayMicroseconds(4);           // tCC = 4us
}


// --------------------------------------------------------
// _DS1302_stop
//
// A helper function to finish the communication.
//
void _DS1302_stop(void)
{
  // Set CE low
  digitalWrite (DS1302_CE, LOW);

  delayMicroseconds(4);           // tCWH = 4us
}


// --------------------------------------------------------
// _DS1302_toggleread
//
// A helper function for reading a byte with bit toggle
//
// This function assumes that the SCLK is still high.
//
uint8_t _DS1302_toggleread(void)
{
  uint8_t i, data;

  data = 0;
  for (i = 0; i <= 7; i++)
  {
    // Issue a clock pulse for the next databit.
    // If the 'togglewrite' function was used before
    // this function, the SCLK is already high.
    digitalWrite (DS1302_SCLK, HIGH);
    delayMicroseconds(1);

    // Clock down, data is ready after some time.
    digitalWrite (DS1302_SCLK, LOW);
    delayMicroseconds(1);        // tCL=1000ns, tCDD=800ns

    // read bit, and set it in place in 'data' variable
    bitWrite (data, i, digitalRead(DS1302_IO));
  }
  return (data);
}


// --------------------------------------------------------
// _DS1302_togglewrite
//
// A helper function for writing a byte with bit toggle
//
// The 'release' parameter is for a read after this write.
// It will release the I/O-line and will keep the SCLK high.
//
void _DS1302_togglewrite(uint8_t data, uint8_t release)
{
  int i;

  for (i = 0; i <= 7; i++)
  {
    // set a bit of the data on the I/O-line
    digitalWrite (DS1302_IO, bitRead(data, i));
    delayMicroseconds(1);     // tDC = 200ns

    // clock up, data is read by DS1302
    digitalWrite (DS1302_SCLK, HIGH);
    delayMicroseconds(1);     // tCH = 1000ns, tCDH = 800ns

    if (release && i == 7)
    {
      // If this write is followed by a read,
      // the I/O-line should be released after
      // the last bit, before the clock line is made low.
      // This is according the datasheet.
      // I have seen other programs that don't release
      // the I/O-line at this moment,
      // and that could cause a shortcut spike
      // on the I/O-line.
      pinMode (DS1302_IO, INPUT);
      digitalWrite (DS1302_IO, LOW); // remove any pull-up
    }
    else
    {
      digitalWrite (DS1302_SCLK, LOW);
      delayMicroseconds(1);       // tCL=1000ns, tCDD=800ns
    }
  }
}
void uurErbij(){
    ds1302_struct rtc;
    rtc.h24.Hour++;

}