#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#include "Display.h"
#include "Time.h"
#include "Button.h"
#include "Clock.h"

#define START_ANIM_POS_X 32
#define START_ANIM_POS_Y 0

void updateTime();

Display display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
Time currentTime;
Time alarmTime;
Button buttonTimeOption(4);
Button buttonAlarmOption(3);
Button buttonHours(6);
Button buttonMinutes(5);
const int switchPin = 2;
const int ledPin = 12;

Clock clock(&display, &currentTime, &alarmTime, &buttonHours, &buttonMinutes, &buttonTimeOption, &buttonAlarmOption, switchPin, ledPin);
unsigned long currentMillis;

int start_frame = 0;


void setup()
{
	Serial.begin(9600);

	// Initialize screen
	if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
		Serial.println(F("SSD1306 allocation failed"));
		for (;;)
			;
	}
	display.clearDisplay();

	// Initialize clock
	clock.init();

	// Sched the interrupt (1 sec - updateTime func)
	Timer1.initialize(1000000);
	Timer1.attachInterrupt(updateTime);
}

void loop()
{
	currentMillis = millis();
	clock.update(currentMillis);
	display.clearDisplay();
	clock.draw();
	display.display();
	delay(100);
}

void updateTime()
{
	clock.schedIncrement();
}


arduino_clock.ino

diagram.json

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

Adafruit GFX Library
Adafruit SSD1306
TimerOne
ArduinoTrace


libraries.txt

#pragma once

/* If the used library is Adafruit_SSD1306 */
#ifdef _Adafruit_SSD1306_H_

// Generic Typo for display
typedef Adafruit_SSD1306 Display;

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)

// All colors (except black) is taken as WHITE
#define TFT_WHITE WHITE
#define TFT_BLACK BLACK
#define TFT_NAVY WHITE
#define TFT_DARKGREEN WHITE
#define TFT_DARKCYAN WHITE
#define TFT_MAROON WHITE
#define TFT_PURPLE WHITE
#define TFT_OLIVE WHITE
#define TFT_LIGHTGREY WHITE
#define TFT_DARKGREY WHITE
#define TFT_BLUE WHITE
#define TFT_GREEN WHITE
#define TFT_CYAN WHITE
#define TFT_RED WHITE
#define TFT_MAGENTA WHITE
#define TFT_YELLOW WHITE
#define TFT_ORANGE WHITE
#define TFT_GREENYELLOW WHITE
#define TFT_PINK WHITE
#define TFT_BROWN WHITE
#define TFT_GOLD WHITE
#define TFT_SILVER WHITE
#define TFT_SKYBLUE WHITE
#define TFT_VIOLET WHITE

/* If used the library _TFT_eSPIH_ */
#elif defined _TFT_eSPIH_
#define SCREEN_WIDTH 240
#define SCREEN_HEIGHT 135

// Define BLACK and WHITE
#define WHITE TFT_WHITE
#define BLACK TFT_BLACK

// Generic Typo for display
typedef TFT_eSPI Display;

#endif

// General Definitions
#define OFF 0
#define ON 1


Display.h

#pragma once

#include <Arduino.h>

class Time {
	private:
	byte hours = 0;
	byte minutes = 0;
	byte seconds = 0;

	public:
	byte getHours();
	byte getMinutes();
	byte getSeconds();
	void setHours(byte hours);
	void setMinutes(byte minutes);
	void setSeconds(byte seconds);
	void setTime(byte hours, byte minutes, byte seconds);
	void incrementSeconds();
};


Time.h

#include "Time.h"

byte Time::getHours()
{
	return hours;
}

byte Time::getMinutes()
{
	return minutes;
}

byte Time::getSeconds()
{
	return seconds;
}

void Time::setHours(byte hours)
{
	this->hours = hours;
}

void Time::setMinutes(byte minutes)
{
	this->minutes = minutes;
}

void Time::setSeconds(byte seconds)
{
	this->seconds = seconds;
}

void Time::setTime(byte hours, byte minutes, byte seconds)
{
	this->hours = hours;
	this->minutes = minutes;
	this->seconds = seconds;
}

void Time::incrementSeconds()
{
	seconds++;
	if (seconds == 60) {
		seconds = 0;
		minutes++;
		if (minutes == 60) {
			minutes = 0;
			hours++;
			if (hours == 24) {
				hours = 0;
			}
		}
	}
}


Time.cpp

#pragma once

#include <Arduino.h>

#define FIRST_CHANGE_STATE 0
#define DEBOUNCE_VALIDATION_STATE 1
#define LONGPRESS_VALIDATION_STATE 2

#define DEBOUNCE_DELAY_MS 50
#define LONGPRESS_TIME_MS 1000

class Button {
	private:
	int pin;
	bool isPressedFlag = false, wasPressedFlag = false, wasLongPressedFlag = false;
	int state = 0;
	int reading;
	int buttonState = HIGH;
	int lastButtonState = HIGH;
	unsigned long lastDebounceTime = 0;
	unsigned long lastPressTime = 0;

	public:
	Button(int pin);
	void update(unsigned long currentMillis);
	bool isPressed();
	bool wasPressed();
	bool wasLongPressed();
};


Button.h

#include "Button.h"

Button::Button(int pin)
{
	this->pin = pin;
	pinMode(pin, INPUT_PULLUP);
}

void Button::update(unsigned long currentMillis)
{
	isPressedFlag = wasPressedFlag = wasLongPressedFlag = false;
	reading = digitalRead(pin);
	switch (state) {
	case FIRST_CHANGE_STATE:
		if (reading != lastButtonState) {
			lastDebounceTime = currentMillis;
			state = DEBOUNCE_VALIDATION_STATE;
		}
		break;
	case DEBOUNCE_VALIDATION_STATE:
		if ((millis() - lastDebounceTime) > DEBOUNCE_DELAY_MS) {
			if (reading == buttonState) {
				state = FIRST_CHANGE_STATE;
				break;
			}
			buttonState = reading;
			lastButtonState = buttonState;
			if (buttonState != LOW)
				break;
			isPressedFlag = wasPressedFlag = true;
			lastPressTime = currentMillis;
			state = LONGPRESS_VALIDATION_STATE;
		}
		break;
	case LONGPRESS_VALIDATION_STATE:
		if (reading != LOW) {
			state = FIRST_CHANGE_STATE;
			break;
		}
		wasPressedFlag = true;
		if (currentMillis - lastPressTime >= LONGPRESS_TIME_MS)
			wasLongPressedFlag = true;
		break;
	}
}

bool Button::isPressed()
{
	return isPressedFlag;
}

bool Button::wasLongPressed()
{
	return wasLongPressedFlag;
}

bool Button::wasPressed()
{
	return wasPressedFlag;
}


Button.cpp

#pragma once

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <TimerOne.h>

#include "Display.h"
#include "Time.h"
#include "Button.h"
#include "AlarmAnimation.h"

#define CLOCK_OPTION 0
#define ALARM_OPTION 1
#define LONGPRESS_UPDATE_DELAY 200
#define LED_BLINK_DELAY 200
#define ANIMATION_BLINK_DELAY 3000

class Clock {
	private:
	/** 
   * The Clock class will only manipulate the Display memory, it will not be in charge of cleaning
   * the screen or transferring the information in the memory to the screen
   */
	Display *display;
	Time *currentTime;
	Time *alarmTime;
	Button *btnHours;
	Button *btnMinutes;
	Button *btnTimeOption;
	Button *btnAlarmOption;
	int switchAlarmPin;
	int ledPin;

	unsigned long lastUpdateButtonTime = 0;
	unsigned long lastUpdateLedTime = 0;
	boolean isAlarmActive = false;
	
	int currFrame = 0;
	boolean isAnimActive = false;
	unsigned long lastAnimationTime = 0;

	void handleHoursButton(Time *selectedTime, Button *btn, unsigned long currentMillis);
	void handleMinutesButton(Time *selectedTime, Button *btn, unsigned long currentMillis);
	void setTime(unsigned long currentMillis);
	void setAlarm(unsigned long currentMillis);
	void checkButtons(unsigned long currentMillis);
	void displayTime();
	void displayAlarm();
	void blinkLed(unsigned long currentMillis);
	void blinkAnimation(unsigned long currentMillis);

	public:
	Clock(Display *d, Time *currT, Time *alarmT, Button *btnH, Button *btnM, Button *btnT, Button *btnA, int swtPin, int lPin);
	Display *getDisplay();
	Time *getTimeObj();
	Time *getAlarmObj();
	Button *getBtnHours();
	Button *getBtnMinutes();
	Button *getBtnTimeOption();
	Button *getBtnAlarmOption();
	void setDisplay(Display *display);
	void setTimeObj(Time *time);
	void setAlarmObj(Time *time);
	void setBtnHours(Button *btn);
	void setBtnMinutes(Button *btn);
	void setBtnTimeOption(Button *btn);
	void setBtnAlarmOption(Button *btn);

	void init();
	void checkAlarm();
	void update(unsigned long currentMillis);
	void draw();
	void schedIncrement();
};


Clock.h

#include "Clock.h"

Clock::Clock(Display *d, Time *currT, Time *alarmT, Button *btnH, Button *btnM, Button *btnT, Button *btnA, int swtPin, int lPin)
{
	display = d;
	currentTime = currT;
	alarmTime = alarmT;
	btnHours = btnH;
	btnMinutes = btnM;
	btnTimeOption = btnT;
	btnAlarmOption = btnA;
	switchAlarmPin = swtPin;
	ledPin = lPin;
}

// TODO: Documentar por que es necesario el isPressed
void Clock::handleHoursButton(Time *selectedTime, Button *btn, unsigned long currentMillis)
{
	if (btn->isPressed())
		selectedTime->setHours(selectedTime->getHours() + 1);

	if (btn->wasLongPressed()) {
		if (currentMillis - lastUpdateButtonTime >= LONGPRESS_UPDATE_DELAY) {
			selectedTime->setHours(selectedTime->getHours() + 1);
			lastUpdateButtonTime = currentMillis;
		}
	}

	if (selectedTime->getHours() > 23)
		selectedTime->setHours(0);
}

void Clock::handleMinutesButton(Time *selectedTime, Button *btn, unsigned long currentMillis)
{
	if (btn->isPressed())
		selectedTime->setMinutes(selectedTime->getMinutes() + 1);

	if (btn->wasLongPressed()) {
		if (currentMillis - lastUpdateButtonTime >= LONGPRESS_UPDATE_DELAY) {
			selectedTime->setMinutes(selectedTime->getMinutes() + 1);
			lastUpdateButtonTime = currentMillis;
		}
	}

	if (selectedTime->getMinutes() > 59)
		selectedTime->setMinutes(0);
}

void Clock::setTime(unsigned long currentMillis)
{
	currentTime->setSeconds(0);

	if (btnHours->wasPressed()) {
		handleHoursButton(currentTime, btnHours, currentMillis);
	} else if (btnMinutes->wasPressed()) {
		handleMinutesButton(currentTime, btnMinutes, currentMillis);
	}
}

void Clock::setAlarm(unsigned long currentMillis)
{
	alarmTime->setSeconds(0);

	if (btnHours->wasPressed()) {
		handleHoursButton(alarmTime, btnHours, currentMillis);
	} else if (btnMinutes->wasPressed()) {
		handleMinutesButton(alarmTime, btnMinutes, currentMillis);
	}
}

void Clock::checkButtons(unsigned long currentMillis)
{
	// Avoid collisions
	if (btnTimeOption->wasPressed() && btnAlarmOption->wasPressed()) {
		Serial.println("Error: Estan presionando ambas opciones al tiempo");
		return;
	}

	if (btnTimeOption->wasPressed()) {
		setTime(currentMillis);
	} else if (btnAlarmOption->wasPressed()) {
		setAlarm(currentMillis);
	}
}

void Clock::displayTime()
{
	display->setTextSize(2);
	display->setTextColor(WHITE);
	display->setCursor(0, 0);
	display->print("TIME:");
	display->setCursor(15, 20);
	display->print(currentTime->getHours() < 10 ? "0" : "");
	display->print(currentTime->getHours());
	display->print(":");
	display->print(currentTime->getMinutes() < 10 ? "0" : "");
	display->print(currentTime->getMinutes());
	display->print(":");
	display->print(currentTime->getSeconds() < 10 ? "0" : "");
	display->print(currentTime->getSeconds());
}

void Clock::displayAlarm()
{
	display->setTextSize(1);
	display->setTextColor(WHITE);
	display->setCursor(0, 40);
	display->print("ALARM:");
	display->setCursor(20, 52);
	display->print(alarmTime->getHours() < 10 ? "0" : "");
	display->print(alarmTime->getHours());
	display->print(":");
	display->print(alarmTime->getMinutes() < 10 ? "0" : "");
	display->print(alarmTime->getMinutes());
	display->print(":");
	display->print(alarmTime->getSeconds() < 10 ? "0" : "");
	display->print(alarmTime->getSeconds());

	display->setTextSize(2);
	display->setCursor(80, 48);
	if (digitalRead(switchAlarmPin))
		display->print("ON");
	else
		display->print("OFF");
}

void Clock::blinkLed(unsigned long currentMillis)
{
	static bool ledState = LOW;
	if (!digitalRead(switchAlarmPin))
	{
		digitalWrite(ledPin, LOW);
		return;
	}
	
	if (currentMillis - lastUpdateLedTime >= LED_BLINK_DELAY)
	{
		lastUpdateLedTime = currentMillis;
		ledState = !ledState;
		digitalWrite(ledPin, ledState);
	}
}

void Clock::blinkAnimation(unsigned long currentMillis)
{
	if (!isAlarmActive)
		return;

	if (currentMillis - lastAnimationTime >= ANIMATION_BLINK_DELAY && !isAnimActive)
	{
		// The last animation time is updated in draw function
		isAnimActive = true;
	}
}

Display *Clock::getDisplay()
{
	return display;
}

Time *Clock::getTimeObj()
{
	return currentTime;
}

Time *Clock::getAlarmObj()
{
	return alarmTime;
}

Button *Clock::getBtnHours()
{
	return btnHours;
}

Button *Clock::getBtnMinutes()
{
	return btnMinutes;
}

Button *Clock::getBtnTimeOption()
{
	return btnTimeOption;
}

Button *Clock::getBtnAlarmOption()
{
	return btnAlarmOption;
}

void Clock::setDisplay(Display *display)
{
	this->display = display;
}

void Clock::setTimeObj(Time *time)
{
	currentTime = time;
}

void Clock::setAlarmObj(Time *time)
{
	alarmTime = time;
}

void Clock::setBtnHours(Button *btn)
{
	btnHours = btn;
}

void Clock::setBtnMinutes(Button *btn)
{
	btnMinutes = btn;
}

void Clock::setBtnTimeOption(Button *btn)
{
	btnTimeOption = btn;
}

void Clock::setBtnAlarmOption(Button *btn)
{
	btnAlarmOption = btn;
}

void Clock::init()
{
	pinMode(ledPin, OUTPUT);

	currentTime->setTime(12, 1, 0);
	alarmTime->setTime(12, 11, 0);
}

void Clock::checkAlarm()
{
	if (currentTime->getHours() != alarmTime->getHours() || currentTime->getMinutes() != alarmTime->getMinutes())
	{
		isAlarmActive = false;
		return;
	}
	isAlarmActive = true;
}

void Clock::update(unsigned long currentMillis)
{
	// Update Buttons State
	btnHours->update(currentMillis);
	btnMinutes->update(currentMillis);
	btnTimeOption->update(currentMillis);
	btnAlarmOption->update(currentMillis);

	// Check changes
	checkButtons(currentMillis);
	checkAlarm();
	
	// Blink led
	if (isAlarmActive)
		blinkLed(currentMillis);
	
	// Animation setup
	blinkAnimation(currentMillis);
}

void Clock::draw()
{
	// Setup animation
	if (isAlarmActive && isAnimActive && digitalRead(switchAlarmPin))
	{
		display->drawBitmap(32, 0, clarr[currFrame], FRAME_WIDTH, FRAME_HEIGHT, 1);
		
		// 1 iteration of animation
		if (currFrame + 1 == FRAME_COUNT)
		{
			isAnimActive = false;
			lastAnimationTime = millis();
		}

		// Update frame value
		currFrame = (currFrame + 1) % FRAME_COUNT;

		// Avoid print clock and alarm when the animation is active
		return;
	}

	// Update memory display
	displayTime();
	displayAlarm();
}

void Clock::schedIncrement()
{
	currentTime->incrementSeconds();
}


Clock.cpp

/**
 * Given the high number of zeros that animation matrices have, a reduction
 * in the size of each animation is sought, this through the use of
 * sparse matrices. The theoretical sources implemented are:
 * - http://dm.udc.es/elearning/MaterialDocente/sparse.pdf
 * - https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html
 */
#pragma once

#define FRAME_DELAY (42)
#define FRAME_WIDTH (64)
#define FRAME_HEIGHT (64)
#define FRAME_COUNT (28)