/*

https://github.com/Makuna/Rtc
Arduino Real Time Clock library.

https://github.com/avishorp/TM1637
Arduino library for TM1637 (LED Driver)

*/

#include <ThreeWire.h>
#include <RtcDS1302.h>
#include "TM1637Display.h"

#define CLK1 9
#define DIO1 10
#define CLK2 11
#define DIO2 12
#define countof(a) (sizeof(a) / sizeof(a[0]))

ThreeWire myWire(6,7,5); // IO, SCLK, CE
RtcDS1302<ThreeWire> Rtc(myWire);
TM1637Display display1(CLK1, DIO1);
TM1637Display display2(CLK2, DIO2);

uint8_t prev_second;
const char data[] = "Hello World";

void setup () 
{
    Serial.begin(115200);
    Rtc.Begin();
    RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__);
    Rtc.SetDateTime(compiled);
    display1.setBrightness(7);
    display2.setBrightness(7);

    for (int i = 0; i < 11; ++i)
    {
        Rtc.SetMemory(i, data[i]);
    }
}

void loop () 
{
    RtcDateTime dt = Rtc.GetDateTime();

    if (dt.Second() != prev_second)
    {
        prev_second = dt.Second();
        uint8_t ram[DS1302RamSize];

        for (int i = 0; i < 11; ++i)
        {
            ram[i] = Rtc.GetMemory(i);
        }
        
        Serial.print((const char*)ram);
        Serial.print(' ');
        printDateTime(dt);
    }

    display1.showNumberDec(dt.Hour(), 0x80, 2, 2);
    display2.showNumberDecEx(dt.Minute(), 0x80, 2, 2);
    display2.showNumberDecEx(dt.Second(), 0x80, true, 2, 2);

    delay(100);
}

void printDateTime(const RtcDateTime& dt)
{
    char datestring[20];

    snprintf_P(datestring, 
            countof(datestring),
            PSTR("%02u/%02u/%04u %02u:%02u:%02u"),
            dt.Month(),
            dt.Day(),
            dt.Year(),
            dt.Hour(),
            dt.Minute(),
            dt.Second());
    Serial.print(datestring);
    Serial.println();
}

DS1302_TM1637.ino

diagram.json

//  Author: avishorp@gmail.com
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef __TM1637DISPLAY__
#define __TM1637DISPLAY__

#include <inttypes.h>

#define SEG_A   0b00000001
#define SEG_B   0b00000010
#define SEG_C   0b00000100
#define SEG_D   0b00001000
#define SEG_E   0b00010000
#define SEG_F   0b00100000
#define SEG_G   0b01000000
#define SEG_DP  0b10000000

#define DEFAULT_BIT_DELAY  100

class TM1637Display {

public:
  //! Initialize a TM1637Display object, setting the clock and
  //! data pins.
  //!
  //! @param pinClk - The number of the digital pin connected to the clock pin of the module
  //! @param pinDIO - The number of the digital pin connected to the DIO pin of the module
  //! @param bitDelay - The delay, in microseconds, between bit transition on the serial
  //!                   bus connected to the display
  TM1637Display(uint8_t pinClk, uint8_t pinDIO, unsigned int bitDelay = DEFAULT_BIT_DELAY);

  //! Sets the brightness of the display.
  //!
  //! The setting takes effect when a command is given to change the data being
  //! displayed.
  //!
  //! @param brightness A number from 0 (lowes brightness) to 7 (highest brightness)
  //! @param on Turn display on or off
  void setBrightness(uint8_t brightness, bool on = true);

  //! Display arbitrary data on the module
  //!
  //! This function receives raw segment values as input and displays them. The segment data
  //! is given as a byte array, each byte corresponding to a single digit. Within each byte,
  //! bit 0 is segment A, bit 1 is segment B etc.
  //! The function may either set the entire display or any desirable part on its own. The first
  //! digit is given by the @ref pos argument with 0 being the leftmost digit. The @ref length
  //! argument is the number of digits to be set. Other digits are not affected.
  //!
  //! @param segments An array of size @ref length containing the raw segment values
  //! @param length The number of digits to be modified
  //! @param pos The position from which to start the modification (0 - leftmost, 3 - rightmost)
  void setSegments(const uint8_t segments[], uint8_t length = 4, uint8_t pos = 0);

  //! Clear the display
  void clear();

  //! Display a decimal number
  //!
  //! Display the given argument as a decimal number.
  //!
  //! @param num The number to be shown
  //! @param leading_zero When true, leading zeros are displayed. Otherwise unnecessary digits are
  //!        blank. NOTE: leading zero is not supported with negative numbers.
  //! @param length The number of digits to set. The user must ensure that the number to be shown
  //!        fits to the number of digits requested (for example, if two digits are to be displayed,
  //!        the number must be between 0 to 99)
  //! @param pos The position of the most significant digit (0 - leftmost, 3 - rightmost)
  void showNumberDec(int num, bool leading_zero = false, uint8_t length = 4, uint8_t pos = 0);

  //! Display a decimal number, with dot control
  //!
  //! Display the given argument as a decimal number. The dots between the digits (or colon)
  //! can be individually controlled.
  //!
  //! @param num The number to be shown
  //! @param dots Dot/Colon enable. The argument is a bitmask, with each bit corresponding to a dot
  //!        between the digits (or colon mark, as implemented by each module). i.e.
  //!        For displays with dots between each digit:
  //!        * 0.000 (0b10000000)
  //!        * 00.00 (0b01000000)
  //!        * 000.0 (0b00100000)
  //!        * 0.0.0.0 (0b11100000)
  //!        For displays with just a colon:
  //!        * 00:00 (0b01000000)
  //!        For displays with dots and colons colon:
  //!        * 0.0:0.0 (0b11100000)
  //! @param leading_zero When true, leading zeros are displayed. Otherwise unnecessary digits are
  //!        blank. NOTE: leading zero is not supported with negative numbers.
  //! @param length The number of digits to set. The user must ensure that the number to be shown
  //!        fits to the number of digits requested (for example, if two digits are to be displayed,
  //!        the number must be between 0 to 99)
  //! @param pos The position of the most significant digit (0 - leftmost, 3 - rightmost)
  void showNumberDecEx(int num, uint8_t dots = 0, bool leading_zero = false, uint8_t length = 4, uint8_t pos = 0);

  //! Display a hexadecimal number, with dot control
  //!
  //! Display the given argument as a hexadecimal number. The dots between the digits (or colon)
  //! can be individually controlled.
  //!
  //! @param num The number to be shown
  //! @param dots Dot/Colon enable. The argument is a bitmask, with each bit corresponding to a dot
  //!        between the digits (or colon mark, as implemented by each module). i.e.
  //!        For displays with dots between each digit:
  //!        * 0.000 (0b10000000)
  //!        * 00.00 (0b01000000)
  //!        * 000.0 (0b00100000)
  //!        * 0.0.0.0 (0b11100000)
  //!        For displays with just a colon:
  //!        * 00:00 (0b01000000)
  //!        For displays with dots and colons colon:
  //!        * 0.0:0.0 (0b11100000)
  //! @param leading_zero When true, leading zeros are displayed. Otherwise unnecessary digits are
  //!        blank
  //! @param length The number of digits to set. The user must ensure that the number to be shown
  //!        fits to the number of digits requested (for example, if two digits are to be displayed,
  //!        the number must be between 0 to 99)
  //! @param pos The position of the most significant digit (0 - leftmost, 3 - rightmost)
  void showNumberHexEx(uint16_t num, uint8_t dots = 0, bool leading_zero = false, uint8_t length = 4, uint8_t pos = 0);

  //! Translate a single digit into 7 segment code
  //!
  //! The method accepts a number between 0 - 15 and converts it to the
  //! code required to display the number on a 7 segment display.
  //! Numbers between 10-15 are converted to hexadecimal digits (A-F)
  //!
  //! @param digit A number between 0 to 15
  //! @return A code representing the 7 segment image of the digit (LSB - segment A;
  //!         bit 6 - segment G; bit 7 - always zero)
  static uint8_t encodeDigit(uint8_t digit);

protected:
   void bitDelay();

   void start();

   void stop();

   bool writeByte(uint8_t b);

   void showDots(uint8_t dots, uint8_t* digits);
   
   void showNumberBaseEx(int8_t base, uint16_t num, uint8_t dots = 0, bool leading_zero = false, uint8_t length = 4, uint8_t pos = 0);


private:
	uint8_t m_pinClk;
	uint8_t m_pinDIO;
	uint8_t m_brightness;
	unsigned int m_bitDelay;
};

#endif // __TM1637DISPLAY__

TM1637Display.h

//  Author: avishorp@gmail.com
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

extern "C" {
  #include <stdlib.h>
  #include <string.h>
  #include <inttypes.h>
}

#include "TM1637Display.h"
#include <Arduino.h>

#define TM1637_I2C_COMM1    0x40
#define TM1637_I2C_COMM2    0xC0
#define TM1637_I2C_COMM3    0x80

//
//      A
//     ---
//  F |   | B
//     -G-
//  E |   | C
//     ---
//      D
const uint8_t digitToSegment[] = {
 // XGFEDCBA
  0b00111111,    // 0
  0b00000110,    // 1
  0b01011011,    // 2
  0b01001111,    // 3
  0b01100110,    // 4
  0b01101101,    // 5
  0b01111101,    // 6
  0b00000111,    // 7
  0b01111111,    // 8
  0b01101111,    // 9
  0b01110111,    // A
  0b01111100,    // b
  0b00111001,    // C
  0b01011110,    // d
  0b01111001,    // E
  0b01110001     // F
  };

static const uint8_t minusSegments = 0b01000000;

TM1637Display::TM1637Display(uint8_t pinClk, uint8_t pinDIO, unsigned int bitDelay)
{
	// Copy the pin numbers
	m_pinClk = pinClk;
	m_pinDIO = pinDIO;
	m_bitDelay = bitDelay;

	// Set the pin direction and default value.
	// Both pins are set as inputs, allowing the pull-up resistors to pull them up
    pinMode(m_pinClk, INPUT);
    pinMode(m_pinDIO,INPUT);
	digitalWrite(m_pinClk, LOW);
	digitalWrite(m_pinDIO, LOW);
}

void TM1637Display::setBrightness(uint8_t brightness, bool on)
{
	m_brightness = (brightness & 0x7) | (on? 0x08 : 0x00);
}

void TM1637Display::setSegments(const uint8_t segments[], uint8_t length, uint8_t pos)
{
    // Write COMM1
	start();
	writeByte(TM1637_I2C_COMM1);
	stop();

	// Write COMM2 + first digit address
	start();
	writeByte(TM1637_I2C_COMM2 + (pos & 0x03));

	// Write the data bytes
	for (uint8_t k=0; k < length; k++)
	  writeByte(segments[k]);

	stop();

	// Write COMM3 + brightness
	start();
	writeByte(TM1637_I2C_COMM3 + (m_brightness & 0x0f));
	stop();
}

void TM1637Display::clear()
{
    uint8_t data[] = { 0, 0, 0, 0 };
	setSegments(data);
}

void TM1637Display::showNumberDec(int num, bool leading_zero, uint8_t length, uint8_t pos)
{
  showNumberDecEx(num, 0, leading_zero, length, pos);
}

void TM1637Display::showNumberDecEx(int num, uint8_t dots, bool leading_zero,
                                    uint8_t length, uint8_t pos)
{
  showNumberBaseEx(num < 0? -10 : 10, num < 0? -num : num, dots, leading_zero, length, pos);
}

void TM1637Display::showNumberHexEx(uint16_t num, uint8_t dots, bool leading_zero,
                                    uint8_t length, uint8_t pos)
{
  showNumberBaseEx(16, num, dots, leading_zero, length, pos);
}

void TM1637Display::showNumberBaseEx(int8_t base, uint16_t num, uint8_t dots, bool leading_zero,
                                    uint8_t length, uint8_t pos)
{
    bool negative = false;
	if (base < 0) {
	    base = -base;
		negative = true;
	}


    uint8_t digits[4];

	if (num == 0 && !leading_zero) {
		// Singular case - take care separately
		for(uint8_t i = 0; i < (length-1); i++)
			digits[i] = 0;
		digits[length-1] = encodeDigit(0);
	}
	else {
		//uint8_t i = length-1;
		//if (negative) {
		//	// Negative number, show the minus sign
		//    digits[i] = minusSegments;
		//	i--;
		//}
		
		for(int i = length-1; i >= 0; --i)
		{
		    uint8_t digit = num % base;
			
			if (digit == 0 && num == 0 && leading_zero == false)
			    // Leading zero is blank
				digits[i] = 0;
			else
			    digits[i] = encodeDigit(digit);
				
			if (digit == 0 && num == 0 && negative) {
			    digits[i] = minusSegments;
				negative = false;
			}

			num /= base;
		}
    }
	
	if(dots != 0)
	{
		showDots(dots, digits);
	}
    
    setSegments(digits, length, pos);
}

void TM1637Display::bitDelay()
{
	delayMicroseconds(m_bitDelay);
}

void TM1637Display::start()
{
  pinMode(m_pinDIO, OUTPUT);
  bitDelay();
}

void TM1637Display::stop()
{
	pinMode(m_pinDIO, OUTPUT);
	bitDelay();
	pinMode(m_pinClk, INPUT);
	bitDelay();
	pinMode(m_pinDIO, INPUT);
	bitDelay();
}

bool TM1637Display::writeByte(uint8_t b)
{
  uint8_t data = b;

  // 8 Data Bits
  for(uint8_t i = 0; i < 8; i++) {
    // CLK low
    pinMode(m_pinClk, OUTPUT);
    bitDelay();

	// Set data bit
    if (data & 0x01)
      pinMode(m_pinDIO, INPUT);
    else
      pinMode(m_pinDIO, OUTPUT);

    bitDelay();

	// CLK high
    pinMode(m_pinClk, INPUT);
    bitDelay();
    data = data >> 1;
  }

  // Wait for acknowledge
  // CLK to zero
  pinMode(m_pinClk, OUTPUT);
  pinMode(m_pinDIO, INPUT);
  bitDelay();

  // CLK to high
  pinMode(m_pinClk, INPUT);
  bitDelay();
  uint8_t ack = digitalRead(m_pinDIO);
  if (ack == 0)
    pinMode(m_pinDIO, OUTPUT);


  bitDelay();
  pinMode(m_pinClk, OUTPUT);
  bitDelay();

  return ack;
}

void TM1637Display::showDots(uint8_t dots, uint8_t* digits)
{
    for(int i = 0; i < 4; ++i)
    {
        digits[i] |= (dots & 0x80);
        dots <<= 1;
    }
}

uint8_t TM1637Display::encodeDigit(uint8_t digit)
{
	return digitToSegment[digit & 0x0f];
}

TM1637Display.cpp

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries
Rtc by Makuna

libraries.txt

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

// Chip information.
typedef struct {
  pin_t VCC;
  pin_t GND;
  pin_t CLK;
  pin_t DAT;
  pin_t RST;
  uint8_t year[2];
  uint8_t month[2];
  uint8_t date[2];
  uint8_t hour[2];
  uint8_t minute[2];
  uint8_t second[2];
  uint8_t day[2];
  uint8_t memory[31];
  uint8_t bcd_index;
  uint8_t bit_in;
  uint8_t bit_out;
  uint8_t cmd;
  uint8_t data;
  uint8_t byte_index;
} chip_data_t;

// Returns true if the power source is connected correctly.
bool power_connected(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  return pin_read(chip->VCC) && !pin_read(chip->GND);
}

// Increments the clock once per second.
void chip_timer_callback(void *data) 
{
  chip_data_t *chip = (chip_data_t*)data;
  if (power_connected(chip))
  {
    if (chip->second[1] == 5 && chip->second[0] == 9)
    {
      if (chip->minute[0] != 9)
      {
        chip->second[1] = 0;
        chip->second[0] = 0;
        chip->minute[0]++;
      }
      else if (chip->minute[1] == 5 && chip->minute[0] == 9)
      {
        chip->minute[0] = 0;
        chip->minute[1] = 0;
        chip->second[0] = 0;
        chip->second[1] = 0;
        if (chip->hour[0] == 9)
        {
          chip->hour[0] = 0;
          chip->hour[1]++;
        }
        else if (chip->hour[1] == 2 && chip->hour[0] == 3)
        {
          chip->hour[1] = 0;
          chip->hour[0] = 0;
        }
        else
        {
          chip->hour[0]++;
        }
      }
      else if (chip->minute[1] != 5 && chip->minute[0] == 9)
      {
        chip->second[0] = 0;
        chip->second[1] = 0;
        chip->minute[0] = 0;
        chip->minute[1]++;
      }
    }
    else if (chip->second[0] == 9)
    {
      chip->second[0] = 0;
      chip->second[1]++;
    }
    else
    {
      chip->second[0]++;
    }
  }
}

// Writes to the given memory address.
void write_memory(void *user_data)
{
  chip_data_t *chip = (chip_data_t*)user_data;
  if (chip->byte_index < 31)
  {
    chip->memory[chip->byte_index - 1] = chip->data;
    chip->byte_index++;
  }
  else
  {
    chip->byte_index = 0;
  }
}

// Outputs the contents of a memory address on DAT pin during low clock cycle.
void read_memory(void *user_data)
{
  chip_data_t *chip = (chip_data_t*)user_data;
  if (chip->bit_out < 8)
  {
    uint8_t bit = (chip->memory[(chip->cmd - 0xC1) / 2] >> chip->bit_out) & 1;
    pin_write(chip->DAT, bit);
    chip->bit_out++;
  }
  else
  {
    chip->DAT = pin_init("DAT", INPUT);
    chip->cmd = 0;
    chip->bit_out = 0;
    chip->byte_index = 0;
  }
}

// Saves incoming date & time when 0xBE TIMEDATE_BURST command is received.
void write_time(void *user_data)
{
  chip_data_t *chip = (chip_data_t*)user_data;
  
  switch (chip->byte_index)
  {
    case 1:
      if (chip->bcd_index < 2)
      {
        chip->second[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index++;
      }
      break;
    case 2:
      if (chip->bcd_index < 2)
      {
        chip->minute[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index++;
      }
      break;
    case 3:
      if (chip->bcd_index < 2)
      {
        chip->hour[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index++;
      }
      break;
    case 4:
      if (chip->bcd_index < 2)
      {
        chip->date[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index++;
      }
      break;
    case 5:
      if (chip->bcd_index < 2)
      {
        chip->month[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index++;
      }
      break;
    case 6:
      if (chip->bcd_index < 2)
      {
        chip->day[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index++;
      }
      break;
    case 7:
      if (chip->bcd_index < 2)
      {
        chip->year[chip->bcd_index] = chip->data;
        chip->bcd_index++;
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->byte_index = 0;
      }
      break;
  }
}

// Outputs date & time on DAT pin after receiving 0xBF TIMEDATE_BURST command. 
void read_time(void *user_data)
{
  chip_data_t *chip = (chip_data_t*)user_data;
  switch (chip->byte_index)
  {
    case 1:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->second[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->second[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_out = 0;
        uint8_t bit = (chip->minute[chip->bcd_index] >> chip->bit_out) & 1;
        pin_write(chip->DAT, bit);
        chip->bit_out++;
        chip->byte_index++;
      }
      break;
    case 2:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->minute[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->minute[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_out = 0;
        uint8_t bit = (chip->hour[chip->bcd_index] >> chip->bit_out) & 1;
        pin_write(chip->DAT, bit);
        chip->bit_out++;
        chip->byte_index++;
      }
      break;
    case 3:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->hour[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->hour[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_out = 0;
        uint8_t bit = (chip->date[chip->bcd_index] >> chip->bit_out) & 1;
        pin_write(chip->DAT, bit);
        chip->bit_out++;
        chip->byte_index++;
      }
      break;
    case 4:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->date[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->date[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_out = 0;
        uint8_t bit = (chip->month[chip->bcd_index] >> chip->bit_out) & 1;
        pin_write(chip->DAT, bit);
        chip->bit_out++;
        chip->byte_index++;
      }
      break;
    case 5:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->month[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->month[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_out = 0;
        uint8_t bit = (chip->day[chip->bcd_index] >> chip->bit_out) & 1;
        pin_write(chip->DAT, bit);
        chip->bit_out++;
        chip->byte_index++;
      }
      break;
    case 6:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->day[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->day[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_out = 0;
        uint8_t bit = (chip->year[chip->bcd_index] >> chip->bit_out) & 1;
        pin_write(chip->DAT, bit);
        chip->bit_out++;
        chip->byte_index++;
      }
      break;
    case 7:
      if (chip->bcd_index < 2)
      {
        if (chip->bit_out < 4)
        {
          uint8_t bit = (chip->year[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
        else
        {
          chip->bit_out = 0;
          chip->bcd_index++;
          uint8_t bit = (chip->year[chip->bcd_index] >> chip->bit_out) & 1;
          pin_write(chip->DAT, bit);
          chip->bit_out++;
        }
      }
      if (chip->bcd_index == 2)
      {
        chip->bcd_index = 0;
        chip->bit_in = 0;
        chip->bit_out = 0;
        chip->cmd = 0;
        chip->data = 0;
        chip->byte_index = 0;
        chip->DAT = pin_init("DAT", INPUT);
      }
      break;
  }
}

// Starts read sequences or carries out write sequences based on command byte. 
void read_command(void *user_data, pin_t pin, uint32_t value)
{
  chip_data_t *chip = (chip_data_t*)user_data;
  
  switch (chip->cmd)
  {
    case 0xBE:
      write_time(user_data);
      break;
    default:
      if (chip->cmd >= 0xC0 && chip->cmd < 0xFE && chip->cmd % 2 == 0)
      { 
        chip->memory[(chip->cmd - 0xC0) / 2] = chip->data;
      }
      chip->byte_index = 0;
      break;
  }
  
  if (chip->byte_index == 0)
  {
    chip->byte_index++;
    chip->cmd = chip->data;
    if (pin == chip->CLK && value == LOW)
    {
      switch (chip->cmd)
      {
        case 0xBF:
          chip->DAT = pin_init("DAT", OUTPUT);
          read_time(user_data);
        default:
          if (chip->cmd >= 0xC0 && chip->cmd < 0xFE && chip->cmd % 2 != 0)
          { 
            chip->DAT = pin_init("DAT", OUTPUT);
            read_memory(user_data);
          }
          break;
      }
    }
  }

  chip->data = 0;
  chip->bit_in = 0;
}

// Reads incoming bits.
void read_incoming(void *user_data, pin_t pin, uint32_t value)
{
  uint8_t bits = 8;
  chip_data_t *chip = (chip_data_t*)user_data;
  uint8_t limit = (chip->cmd == 0xBE) ? 4 : 8;
  if (chip->bit_in < limit)
  {
    if (pin == chip->CLK && value == HIGH)
    {
      uint8_t binary [8] = { 1, 2, 4, 8, 16, 32, 64, 128 };
      uint8_t add = pin_read(chip->DAT) * binary[chip->bit_in];
      chip->data += add;
      chip->bit_in++;
    }
  }
  else
  {
    read_command(user_data, pin, value);
  }
}

// Called whenever the clock pin changes state.
void chip_pin_change(void *user_data, pin_t pin, uint32_t value)
{
  chip_data_t *chip = (chip_data_t*)user_data;

  if (!power_connected(chip))
  {
    return;
  }

  switch(chip->cmd)
  {
    case 0xBF:
      if (pin == chip->CLK && value == LOW)
      {
        chip->DAT = pin_init("DAT", OUTPUT);
        read_time(user_data);
      }
      break;
    default:
      if (chip->cmd >= 0xC0 && chip->cmd < 0xFE && chip->cmd % 2 != 0)
      { 
        if (pin == chip->CLK && value == LOW)
        {
          chip->DAT = pin_init("DAT", OUTPUT);
          read_memory(user_data);
        }
      }
      else
      {
        read_incoming(user_data, pin, value);
      }
      break;
  }
}

// Initializes the chip.
void chip_init()
{
  chip_data_t *chip_data = (chip_data_t*)malloc(sizeof(chip_data_t));
  
  chip_data->VCC = pin_init("VCC", INPUT);
  chip_data->GND = pin_init("GND", INPUT);
  chip_data->CLK = pin_init("CLK", INPUT);
  chip_data->DAT = pin_init("DAT", INPUT);
  chip_data->RST = pin_init("RST", INPUT);

  const pin_watch_config_t watch_config = {
    .edge = BOTH,
    .pin_change = chip_pin_change,
    .user_data = chip_data,
  };
  pin_watch(chip_data->CLK, &watch_config);

  const timer_config_t config = 
  {
    .callback = chip_timer_callback,
    .user_data = chip_data,
  };

  timer_t timer_id = timer_init(&config);
  timer_start(timer_id, 1000000, true);
}