diagram.json

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

Adafruit SSD1306


libraries.txt

#include "Arduino.h"
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

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

void updateTime();

hw_timer_t *timer = NULL;

Display display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
Time currentTime;
Time alarmTime;
Button buttonTimeOption(25);
Button buttonAlarmOption(26);
Button buttonHours(33);
Button buttonMinutes(32);
const int switchPin = 5;
const int buzzerPin = 19;
const int ledPin = 13;

ClockConfig config = {
		&display,
		&currentTime,
		&alarmTime,
		&buttonHours,
		&buttonMinutes,
		&buttonTimeOption,
		&buttonAlarmOption,
		switchPin,
		buzzerPin,
		ledPin};

MainClock clockobj(&config);
unsigned long currentMillis;

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

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

	// Initialize MainClock
	clockobj.init();

	// Sched the interrupt (1 sec - updateTime func)
	timer = timerBegin(0, 80, true);								// Timer 0, divisor de reloj 80
	timerAttachInterrupt(timer, &updateTime, true); // Adjuntar la función de manejo de interrupción
	timerAlarmWrite(timer, 1000000, true);					// Interrupción cada 1 segundo
	timerAlarmEnable(timer);												// Habilitar la alarma
}

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

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


esp32_clock.ino

#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"

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

AlarmAnimation.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 "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 "Clock.h"



MainClock::MainClock(ClockConfig *config)
{
	display = config->display;
	currentTime = config->currentTime;
	alarmTime = config->alarmTime;
	btnHours = config->btnHours;
	btnMinutes = config->btnMinutes;
	btnTimeOption = config->btnTimeOption;
	btnAlarmOption = config->btnAlarmOption;
	switchAlarmPin = config->switchAlarmPin;
	ledPin = config->ledPin;
	buzzerpin = config->buzzerpin;
}

// TODO: Documentar por que es necesario el isPressed
void MainClock::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 MainClock::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 MainClock::setTime(unsigned long currentMillis)
{
	currentTime->setSeconds(0);

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

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

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

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

	clockState = NORMAL_OPTION;
	if (btnTimeOption->wasPressed())
	{
		clockState = (clockState != CLOCK_OPTION) ? CLOCK_OPTION : NORMAL_OPTION;
		setTime(currentMillis);
	}
	else if (btnAlarmOption->wasPressed())
	{
		clockState = (clockState != ALARM_OPTION) ? ALARM_OPTION : NORMAL_OPTION;
		setAlarm(currentMillis);
	}
}

void MainClock::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());

	// Change indicator
	if (clockState == CLOCK_OPTION) {
		display->setTextSize(2);
		display->setTextColor(WHITE);
		display->setCursor(110, 2);
		display->print("T");
	}
}

void MainClock::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");
	
	// Change indicator
	if (clockState == ALARM_OPTION) {
		display->setTextSize(2);
		display->setTextColor(WHITE);
		display->setCursor(110, 2);
		display->print("A");
	}
}

void MainClock::blinkLed(unsigned long currentMillis)
{
	static bool ledState = LOW;
	if (!digitalRead(switchAlarmPin))
	{
		digitalWrite(ledPin, LOW);
		Serial.println("S-OFF");
		return;
	}

	if (currentMillis - lastUpdateLedTime >= LED_BLINK_DELAY)
	{
		lastUpdateLedTime = currentMillis;
		ledState = !ledState;
		digitalWrite(ledPin, ledState);
		Serial.println(ledState? "ON" : "OFF");
	}
}

void MainClock::blinkBuzzer(unsigned long currentMillis)
{
	static bool buzzerStatus = LOW;
	if (!digitalRead(switchAlarmPin))
	{
		noTone(buzzerpin);
		return;
	}

	if (currentMillis - lastUpdateBuzzerTime >= BUZZER_BLINK_DELAY)
	{
		lastUpdateBuzzerTime = currentMillis;
		buzzerStatus = !buzzerStatus;
		if (buzzerStatus)
			tone(buzzerpin, 440);
		else
			noTone(buzzerpin);
	}
}

void MainClock::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 *MainClock::getDisplay()
{
	return display;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void MainClock::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);
		blinkBuzzer(buzzerpin);
	}

	// Animation setup
	blinkAnimation(currentMillis);
}

void MainClock::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 MainClock::schedIncrement()
{
	currentTime->incrementSeconds();
}


Clock.cpp

#pragma once

#include "Arduino.h"

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

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

#define NORMAL_OPTION -1
#define CLOCK_OPTION 0
#define ALARM_OPTION 1
#define LONGPRESS_UPDATE_DELAY 200
#define LED_BLINK_DELAY 1000
#define BUZZER_BLINK_DELAY 1000
#define ANIMATION_BLINK_DELAY 3000

typedef struct
{
	Display *display;
	Time *currentTime;
	Time *alarmTime;
	Button *btnHours;
	Button *btnMinutes;
	Button *btnTimeOption;
	Button *btnAlarmOption;
	int switchAlarmPin;
	int ledPin;
	int buzzerpin;
} ClockConfig;

class MainClock
{
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;
	int buzzerpin;

	unsigned long lastUpdateButtonTime = 0;
	unsigned long lastUpdateLedTime = 0;
	unsigned long lastUpdateBuzzerTime = 0;
	boolean isAlarmActive = false;

	int currFrame = 0;
	boolean isAnimActive = false;
	unsigned long lastAnimationTime = 0;
	int clockState = NORMAL_OPTION;

	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 blinkBuzzer(unsigned long currentMillis);
	void blinkAnimation(unsigned long currentMillis);

public:
	MainClock(ClockConfig *config);
	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

#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
