#include <LiquidCrystal_I2C.h>
#include "Clock.h"

LiquidCrystal_I2C lcd(0x27, 16, 2);
Clock rtc;

bool changeHrs, changeMins;
int pressCnt;

void setup() {
  rtc.begin();
  lcd.init();
  lcd.backlight();

  pinMode(A0, INPUT);
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
}

void loop() {
  DateTime time = rtc.now();

  int hr = time.hour();
  int min_ = time.minute();
  int sec = time.second();

  if (millis() > 30000)
  {
    lcd.noBacklight();
  }
  
  if (!analogRead(A0))
  {
    pressCnt++;
  }

  switch (pressCnt)
  {
    case 0:
      lcd.setCursor(0, 1);
      lcd.println("   ");
      changeHrs, changeMins = false;
      break;

    case 1:
      lcd.setCursor(0, 1);
      lcd.println("hr ");
      changeHrs = true;
      changeMins = false;
      break;

    case 2:
      lcd.setCursor(0, 1);
      lcd.println("min");
      changeHrs = false;
      changeMins = true;
      break;

    case 3:
      pressCnt = 0;
      break;
  }

  if (hr == 60)
  {
    hr = 0;
  }
  else if (min_ == 60)
  {
    min_ = 0;
  }
  else if (sec == 60)
  {
    sec = 0;
  }

  lcd.home();
  
  if (hr < 10)
  {
    lcd.print(String("0") + hr + String(":"));
  }
  else
  {
    lcd.print(hr + String(":"));
  }

  lcd.setCursor(3, 0);

  if (min_ < 10)
  {
    lcd.print(String("0") + min_ + String(":"));
  }
  else
  {
    lcd.print(min_ + String(":"));
  }

  lcd.setCursor(6, 0);

  if (sec < 10)
  {
    lcd.print(String("0") + sec);
  }
  else
  {
    lcd.print(sec);
  }
}

alarm-clock.ino

This digital alarm clock displays the time on a 4-digit 7-segment display. It has the following features:

- Two buttons for setting the current time (Hour / Minute)
- Programable alarm with a snooze function
- The alarm sound can be easily customized in code, and even play melodies
- The colon symbol blinks to indicate seconds
- Optional [RTC](https://en.wikipedia.org/wiki/Real-time_clock) to make the clock more accurate
- Power loss recovery: current time and alarm settings are stored in RTC

### How to use the clock

To set the time, press the _Minute_/_Hour_ buttons.

Pressing the _Alarm_ button enables/disables the alarm. The screen will display the alarm state by showing the word "on" or "off".

After enabling the alarm, the current alarm time will be displayed for a few seconds. You can use the _Minute_/_Hour_ buttons to adjust the alarm time. To finish, press the _Alarm_ button again, or just wait a few seconds.

When the alarm goes off, press the _Alarm_ button briefly to snooze it for
[9 minutes](https://mashable.com/article/everything-you-need-to-know-about-snooze-button-alarm-clocks/). The screen will display four circles to let you know that the alarm was snoozed.

To stop the alarm, hold down the _Alarm_ button for one second or more.

### Project Structure

The code is divided into several modules:

1. [config.h](#source-config_h) - Configuration options for the clock: whether to use an RTC chip, Snooze time, and more. Using a configuration file a common practice when you have several modules in your program.
2. [alarm-clock.ino](#source-alarm_clock_ino) - The main program code. It manages the user interface: the 7-segment display and the buttons.
3. [Clock](#source-clock_h) - The `Clock` class manages the current time and the alarm state machine. It uses the [RTClib](https://github.com/adafruit/RTClib) library to communicate with the RTC chip and track time.
4. [AlarmTone](#source-clock_h) - The `AlarmTone` class play the alarm sound. You can change the values of the `TONES` array, `TONE_TIME` and `TONE_SPACING` to customize the alarm and play different tones and melodies.

### Hardware

| Item              | Quantity | Notes                                 |
| ----------------- | -------- | ------------------------------------- |
| Arduino Uno R3    | 1        |                                       |
| 4-Digit 7-Segment | 4        | Common Anode, 14 pins                 |
| 220Ω Resistor     | 8        | Connect to the 7-segment segment pins |
| PNP Transistor    | 4        | Optional, recommended                 |
| 4.7kΩ Resistor    | 4        | If you use the PNP transistors        |
| 12mm Push button  | 3        |                                       |
| Piezo Buzzer      | 1        | Used for the alarm                    |
| DS1307 RTC        | 1        | Optional                              |

- You can also use a Common Cathode 7-segment display, just adjust the `DISPLAY_TYPE` constant in [config.h](#source-config_h), and switch to NPN transistors.

To keep the clock hardware down to minimum, the Arduino controls the 7-Segment display directly, using the [SevSeg](https://www.arduinolibraries.info/libraries/sev-seg) library.
This approach has a downside, however: it uses 12 GPIO pins!

If you want to save on Arduino pins, you can use a _74HC595_ shift register to cut the pin usage down to 6, or even a 7-Segment display with an integrated controller chip, such as
_TM1637_, _HT16K33_, or _MAX7219_. In this case, you will need to change the code to use a different display library (_SevSeg_ does not support this case), but this is out of the scope of this project.

### Pin Connections

| Arduino Uno Pin | Device           | Device Pin |
| --------------- | ---------------- | ---------- |
| 2               | 7-Segment        | 14 (Dig 1) |
| 3               | 7-Segment        | 11 (Dig 2) |
| 4               | 7-Segment        | 10 (Dig 3) |
| 5               | 7-Segment        | 6 (Dig 4)  |
| 6               | 7-Segment        | 13 (A)     |
| 7               | 7-Segment        | 9 (B)      |
| 8               | 7-Segment        | 4 (C)      |
| 9               | 7-Segment        | 2 (D)      |
| 10              | 7-Segment        | 1 (E)      |
| 11              | 7-Segment        | 12 (F)     |
| 12              | 7-Segment        | 5 (G)      |
| 13              | 7-Segment        | 8 (Colon)  |
| A0              | Hour Button      | -          |
| A1              | Minute Button    | -          |
| A2              | Alarm Button     | -          |
| A3              | Buzzer / Speaker | -          |
| A4              | DS1307 RTC       | SDA        |
| A5              | DS1307 RTC       | SCL        |

- The pin numbers for your 7-segment display may differ. Please consult the datasheet relevant to your device to find out the relevant pin numbers.


README.md

diagram.json

#ifndef __ALARM_TONE_H__
#define __ALARM_TONE_H__

class AlarmTone {
  public:
    AlarmTone();
    void begin(uint8_t pin);
    void play();
    void stop();

  private:
    uint8_t _pin;
    bool _playing;
    uint8_t _tone_index;
    unsigned long _last_tone_time;
};

#endif /* __ALARM_TONE_H */


AlarmTone.h

#include <Arduino.h>
#include "AlarmTone.h"

#define TONE_TIME 500 /* ms */
#define TONE_SPACING 100 /* ms */

static const uint16_t TONES[] = {
  500,
  800,
};
const uint16_t NUM_TONES = sizeof(TONES) / sizeof(TONES[0]);

AlarmTone::AlarmTone()
: _playing(false)
, _tone_index(0)
, _last_tone_time(0) {
}

void AlarmTone::begin(uint8_t pin) {
  _pin = pin;
  pinMode(_pin, OUTPUT);
}

void AlarmTone::play() {
  if (!_playing || _last_tone_time + TONE_TIME + TONE_SPACING < millis()) {
    tone(_pin, TONES[_tone_index], TONE_TIME);
    _tone_index = (_tone_index + 1) % NUM_TONES;
    _last_tone_time = millis();
  }
  _playing = true;
}

void AlarmTone::stop() {
  noTone(_pin);
  _tone_index = 0;
  _playing = false;
}


AlarmTone.cpp

/*
	Button - a small library for Arduino to handle button debouncing

	MIT licensed.
*/

#ifndef Button_h
#define Button_h
#include "Arduino.h"

class Button
{
	public:
		Button(uint8_t pin, uint16_t debounce_ms = 100);
		void begin();
		bool read();
		bool toggled();
		bool pressed();
		bool released();
		bool has_changed();
		uint16_t repeat_count();
		void set_repeat(int16_t delay_ms, int16_t repeat_ms);

		const static bool PRESSED = LOW;
		const static bool RELEASED = HIGH;

	private:
		uint16_t repeats_since_press();

		uint8_t  _pin;
		uint16_t _delay;
		bool     _state;
		uint32_t _ignore_until;
		bool     _has_changed;
		uint16_t _reported_repeats;
		int16_t  _repeat_delay_ms;
		int16_t  _repeat_ms;
};

#endif


Button.h

/*
	Button - a small library for Arduino to handle button debouncing

	MIT licensed.
*/

#include "Button.h"
#include <Arduino.h>

Button::Button(uint8_t pin, uint16_t debounce_ms)
:  _pin(pin)
,  _delay(debounce_ms)
,  _state(HIGH)
,  _ignore_until(0)
,  _has_changed(false)
,  _reported_repeats(0)
,  _repeat_delay_ms(-1)
,  _repeat_ms(-1)
{
}

void Button::begin()
{
	pinMode(_pin, INPUT_PULLUP);
}

//
// public methods
//

bool Button::read()
{
	// ignore pin changes until after this delay time
	if (_ignore_until > millis())
	{
		// ignore any changes during this period
	}

	// pin has changed
	else if (digitalRead(_pin) != _state)
	{
		_state = !_state;

		if (_state == RELEASED)
		{
			_reported_repeats = repeats_since_press();
		}

		else
		{
			_reported_repeats = 0;
		}

		_ignore_until = millis() + _delay;
		_has_changed = true;
	}

	return _state;
}

// has the button been toggled from on -> off, or vice versa
bool Button::toggled()
{
	read();
	return has_changed();
}

// mostly internal, tells you if a button has changed after calling the read() function
bool Button::has_changed()
{
	if (_has_changed)
	{
		_has_changed = false;
		return true;
	}
	return false;
}

// how many repeated press events occured since the button was pressed
uint16_t Button::repeat_count()
{
	return _state == PRESSED ? repeats_since_press() : _reported_repeats;
}

// has the button gone from off -> on or pressed repeatedly
bool Button::pressed()
{
	if (read() == PRESSED)
	{
		uint16_t old_repeats = _reported_repeats;
		_reported_repeats = repeats_since_press();
		return (has_changed() || old_repeats != _reported_repeats);
	}
	else
	{
		return false;
	}
}

// has the button gone from on -> off
bool Button::released()
{
	return (read() == RELEASED && has_changed());
}

void Button::set_repeat(int16_t delay_ms, int16_t repeat_ms)
{
	_repeat_delay_ms = delay_ms > _delay ? delay_ms - _delay : 0;
	_repeat_ms = repeat_ms;
}

uint16_t Button::repeats_since_press()
{
 	if (_repeat_delay_ms == -1 || millis() < _ignore_until + _repeat_delay_ms)
	{
		return 0;
	}

	if (_repeat_ms <= 0)
	{
		return 1;
	}

	uint32_t press_time = millis() - _ignore_until;
	return 1 + (press_time - _repeat_delay_ms) / _repeat_ms;
}


Button.cpp

/**
   Arduino Digital Alarm Clock

   Copyright (C) 2020, Uri Shaked.
   Released under the MIT License.

   Clock Configuration File.
*/

#ifndef __CONFIG_H__
#define __CONFIG_H__

/**
   Change to 0 for running without an external RTC (Real time clock)
*/
#define USE_RTC 1

/**
   Your 7-Segment display type: COMMON_ANODE or COMMON_CATHODE
*/
#define DISPLAY_TYPE COMMON_ANODE

/**
   For how long should we show the alarm status (on/off)?
*/
const int ALARM_STATUS_DISPLAY_TIME = 1000; /* ms */

/**
   For how long should we show the alarm hour?
*/
const int ALARM_HOUR_DISPLAY_TIME = 2500; /* ms */

/**
   For how long should we display the snooze screen?
*/
const int SNOOZE_DISPLAY_TIME = 500; /* ms */

/**
   How many minutes to snooze the alarm for?
*/
const int SNOOZE_TIME = 9; /* minutes */

/**
   The default Alarm hour (for non-RTC mode)
*/
const int DEFAULT_ALARM_HOUR = 9;

#endif /* __CONFIG_H__ */


config.h

#ifndef __CLOCK_H__
#define __CLOCK_H__

#include <RTClib.h>
#include "config.h"

enum AlarmState {
  ALARM_DISABLED,
  ALARM_OFF,
  ALARM_ACTIVE,
  ALARM_SNOOZED,
  ALARM_STOPPED,
};

class Clock {
public:
  Clock();
  void begin();

  /* Clock management */
  DateTime now();
  void incrementMinute();
  void incrementHour();

  /* Alarm Management */
  bool alarmEnabled();
  DateTime alarmTime();
  bool alarmActive();
  void toggleAlarm();
  void snooze();
  void stopAlarm();
  void incrementAlarmHour();
  void incrementAlarmMinute();

protected:
  bool _isAlarmDueTime();

  #if USE_RTC
    RTC_DS1307 _rtc;
  #else /* USE_RTC */
    RTC_Millis _rtc;
  #endif /* USE_RTC */

  byte _alarm_hour;
  byte _alarm_minute;
  AlarmState _alarm_state;
  unsigned long _alarm_snooze_time;
};

#endif /* __CLOCK_H__ */


Clock.h

#include <Arduino.h>
#include "Clock.h"

#define MINUTE 60 * 1000L /* ms */
#define TIMESPAN_DAY TimeSpan(1, 0, 0, 0)

#define NVRAM_ADDR_ALARM_ENABLED 0
#define NVRAM_ADDR_ALARM_HOUR    1
#define NVRAM_ADDR_ALARM_MINUTE  2


Clock::Clock()
  : _alarm_state(ALARM_OFF)
  , _alarm_snooze_time(0)
  , _alarm_hour(DEFAULT_ALARM_HOUR)
  , _alarm_minute(0) {
}

void Clock::begin() {
# if USE_RTC
  if (!_rtc.begin()) {
    Serial.println("Couldn't find RTC");
    abort();
  }
  _alarm_state = _rtc.readnvram(NVRAM_ADDR_ALARM_ENABLED) ? ALARM_OFF : ALARM_DISABLED;
  _alarm_hour = _rtc.readnvram(NVRAM_ADDR_ALARM_HOUR) % 24;
  _alarm_minute = _rtc.readnvram(NVRAM_ADDR_ALARM_MINUTE) % 60;
# else /* USE_RTC */
  DateTime zeroTime;
  _rtc.begin(zeroTime);
# endif
}

/***** Clock management *****/

DateTime Clock::now() {
  return _rtc.now();
}

void Clock::incrementMinute() {
  DateTime now = _rtc.now();
  DateTime newTime = DateTime(now.year(), now.month(), now.day(), now.hour(),
                              (now.minute() + 1) % 60);
  _rtc.adjust(newTime);
}

void Clock::incrementHour() {
  DateTime now = _rtc.now();
  DateTime newTime = DateTime(now.year(), now.month(), now.day(),
                              (now.hour() + 1) % 24, now.minute());
  _rtc.adjust(newTime);
}

/***** Alarm management *****/
bool Clock::_isAlarmDueTime() {
  auto currentTime = now();
  auto alarm = alarmTime();
  return ((currentTime.hour() == alarm.hour())
          && (currentTime.minute() == alarm.minute()));
}

bool Clock::alarmEnabled() {
  return _alarm_state != ALARM_DISABLED;
}

bool Clock::alarmActive() {
  switch (_alarm_state) {
    case ALARM_DISABLED:
      return false;

    case ALARM_OFF:
      if (_isAlarmDueTime()) {
        _alarm_state = ALARM_ACTIVE;
        return true;
      }
      return false;

    case ALARM_ACTIVE:
      return true;

    case ALARM_SNOOZED:
      if (millis() >= _alarm_snooze_time) {
        _alarm_state = ALARM_ACTIVE;
        return true;
      }
      return false;

    case ALARM_STOPPED:
      if (!_isAlarmDueTime()) {
        _alarm_state = ALARM_OFF;
      }
      return false;

    default:
      return false;
  }
}


void Clock::toggleAlarm() {
  bool enabled = !alarmEnabled();
  _alarm_state = enabled ? ALARM_OFF : ALARM_DISABLED;
# if USE_RTC
  _rtc.writenvram(NVRAM_ADDR_ALARM_ENABLED, enabled);
# endif
}

DateTime Clock::alarmTime() {
  DateTime now = _rtc.now();
  DateTime alarm = DateTime(now.year(), now.month(), now.day(), _alarm_hour, _alarm_minute);
  return alarm >= now ? alarm : alarm + TIMESPAN_DAY;
}

void Clock::snooze() {
  _alarm_state = ALARM_SNOOZED;
  _alarm_snooze_time = millis() + SNOOZE_TIME * MINUTE;
}

void Clock::stopAlarm() {
  _alarm_state = ALARM_STOPPED;
}

void Clock::incrementAlarmHour() {
  _alarm_hour = (_alarm_hour + 1) % 24;
  _alarm_state = ALARM_OFF;
# if USE_RTC
  _rtc.writenvram(NVRAM_ADDR_ALARM_HOUR, _alarm_hour);
# endif
}

void Clock::incrementAlarmMinute() {
  _alarm_minute = (_alarm_minute + 1) % 60;
  _alarm_state = ALARM_OFF;
# if USE_RTC
  _rtc.writenvram(NVRAM_ADDR_ALARM_MINUTE, _alarm_minute);
# endif
}


Clock.cpp

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

# Automatically added based on includes:
SevSeg
RTClib
LiquidCrystal I2C