< Back | Github repository | Project page on Hackaday.io

The Alarm Clock with a complete deactivation sequence based on probably too many movies

There's something in the movies I always thought it was pretty cool: that part when someone needs to activate a special device/weapon/whatever by turning a couple of keys at the same time and then pressing a bunch of buttons or using a keypad with an authorization code. The idea of a precise and complex combination in order to perform that powerful and relevant action got me 'cause, well, knobs, buttons, switches and leds blinking.

(btw, this procedures are, more or less, real. Check out the Two-man rule related to the nuclear stuff from the USA and things like that).

And, since the nuclear weapons part is not cool (or, in general, anything involving weapons), what if I build a digital clock that emulates this kind of system in order to turn off the alarm sound once it starts beeping?

Introducing the Alarm Clock with a complete deactivation sequence based on probably too many movies

An Arduino-based clock (with an RTC module) that displays the time, triggers an alarm and, most important, handles the unnecessary complex way to turn it off once it's active. See the device beeping and doing alarm clock stuff here!

Some of its features include:

Real time clock module (powered by external battery, so the main device can be unplugged without any problem)
Alarm based on that RTC module
Time setting options using the device itself (no need to connect the Arduino again in order to change the current time or alarm)
Enable or disable the alarm (it seems pretty obvius, but it can do it! :D)
Switch between AM/PM - 24h mode
A nice custom 3D-printed case that can be definitely improved (this was one of my first attempts in designing something like that from scratch)
Overengineering capabilities to the max (and nope, this won't replace my phone alarm - the one I usually use)

The tl;dr section

I made a clock inspired on the two-key devices that appears in the movies so, in order to shutdown the alarm, you need to turn simultaneously two keys and enter a code in a keypad.
It's an Arduino-based project with a RTC module (and a bunch of buttons, leds, keypads, etc.).
The source code is available on my github page (it's basically a long finite-state machine that works between clock mode and alarm mode, with some other states between and different modules for each of the "things" you need to turn off - like the keys or the keypad).
There's a page on Hackaday.io for this project.
The box is also custom-made and 3D-printed by me (with almost no experience at all in this field).
In this page there's more info about the project, how I made it, some pics and some fancy flowcharts about how it works.
See it in action!

Initial idea and design

Despite the fact that I've always wanted to build something around that "two-key concept", the idea of putting it inside an alarm clock came to me recently. Based on that, I thought about how many "steps" would be necessary to deactivate the system (in this case, two: the two keys and a numeric code using a keypad).

(in my head these drawings made more sense that it might seem, I promise!)

The clock is a simple state machine that works between the clock mode, the alarm mode and the setting mode. When acting as a regular clock (in clock mode) it will show the current time and wait for the alarm trigger. The alarm mode is a step that activates a more complex state machine (an alarm state machine) that will retain the clock state there (beeping the alarm) until all the steps for this other machine are succesfully fullfiled (so the alarm state machine controls all the inputs, the two keys turn action, the keypad code, etc.).

There's also a setting mode the user can enter from the clock mode in order to set the current time and the alarm time.

graph LR A(Clock mode) -- alarm triggered --> B(Alarm mode) B -- alarm
beeping --> B B -- alarm stoped --> A A -- access to
setting mode --> C(Setting mode) C -- settings done --> A

The alarm mode starts in an "idle" first step which means "do nothing since the alarm has not been triggered yet". After that, the only possible change needs to be done by the alarm triggering itself, advancing to a state in which the alarm is actually beeping and no shutdown sequence has been initiated (no keys turned, no code set, etc.).

graph LR A(Idle mode) -- alarm triggered --> B(Full armed) A ---> A B -- 2-key sequence completed --> C(Waiting keypad) B ---> B C -- keypad correct --> D(Waiting button) C --> C C -. reset .-> B D -- button pressed --> A D --> D

First, both of the keys need to be turned right at the same time. When this action is performed in a proper way (there's a certain delay between one key is activated and the other one is turned too, so there's a "human valid range" in order to avoid checking both of the keys in the same Arduino's clock tick - which I think is something pretty impossible for a human being to do :_D) a code will be required. Once that code is entered correctly (it can be repeated until it's a valid one) a final red button must be pressed to turn off the alarm and go to the initial idle state.

Trying to push the red button before any of the other actions (there're some leds showing every step, so no confusion here) will trigger a reset action that will move us to the full armed status. This will require to re-activate the keys again (basically turn left and right again) and then move to the keypad code.

Each of the "physical modules" that we need to complete before the red button is pressed is also a little state machine that works as a closed blackbox: it'll only deliver a "completed", "non-completed" or "idle" status, so the system only needs to ask to each module about their state (leaving the internal settings and checks to that module). Translating this into code means the two keys switches are a full C++ class that is used as "the two_keys object"; and the keypad is known as "the keypad class".

The two keys system

graph LR A(Reset) -- after certain delay --> B(Idle) A ---> A B ---> B B -- alarm triggered --> C(No keys activated) C ---> C C -. at least one key was
already activated .-> A C -- one key activated --> D(One key activated) D ---> D D -. timeout between two keys .-> A D -. first key de-activated .-> A D -- other key activated --> E(Both keys activated) E ---> E

There's a "base" idle state in which nothing can be performed until the alarm is triggered and the two keys system becomes ready. Being ready means "waiting for BOTH of the keys" so each time a discrepancy appears (like changing from "idle" to "no keys activated" having one key already turned, which is something we don't want) we jump to the reset state.

The reset state will wait for a few milliseconds and then try to check if both of the keys are turned off. Otherwise, it'll perform in that state until the desired initial state can be fullfiled (otherwise we could bypass the sequence by just having both of the keys constantly turned on!).

Once a key is activated it'll wait until the second one (that's our best case scenario) and then move to the final state: both keys are currently activated, so the alarm can pick up that state and do other things.

BUT if there's too much time between one key and the other, or if the first one is de-activated before the second one, then we go back to the reset state.

Also notice that once the final state is reached, the keys can be freely turned on and off and nothing will happen (the state has been reached, so this doesn't matter anymore until the alarm resets the whole system).

The code in the keypad

graph LR A(Idle) ---> A A -- config mode triggered --> B(Config mode) A -- alarm triggered --> C(Waiting code) B ---> B B -- configuration
finished --> A C ---> C C -- code validated -->D(Valid code) D ---> D

Pretty similar to the two keys module (being idle on the clock, changing to waiting code with the alarm, remaining on the finished state at the end) but with a small difference: while being in idle mode the module can read some keystrokes in order to change to config mode or perform some minor actions like switching between AM/PM - 24h or enabling/disabling the alarm.

It's the main system (or main state machine, main class, whatever you wanna call it...) the one that handles the configuration of the clock, using the keypad module ONLY to fetch the pressed keys but without performing any action by itself.

Prototyping

part list:

2 key switches (they act as regular push buttons but using keys that close the contact when turning it)
1 3x4 matrix keypad (I used this one)
1 Adafruit 4-Digit 7-Segment Display Backpack (basically an I2C device to control the 4 numbers in the leds)
1 Arduino Mega (maybe I could shorten the number of pins by using shifters for the leds and stuff like that, but I just go and use a bigger arduino to make it easier - and now there's plenty of space for new modules and improvements)
1 Adafruit DS3231 Precision RTC Breakout (a small real time clock via I2C)
1 small buzzer (for the alarm!)
1 555 Timer
Some resistors
Some nuts and bolts
1 red push button
A bunch of red and green leds
A bunch of led cases/protectors/things where you put the leds to look fancier than just in the box
Wires, some PCBs, tools...

Once the alarm is triggered a certain pin on the Arduino will go high so we can attach there whatever we wanna show/display/power/beep. In my case I use a 555 timer in an astable mode to create some intervals for the buzzer (powered using a transistor). Needless to say, this signal can be used to trigger any other thing (maybe a relay connected to a more powerful horn?) or even modify it so we doesn't need the astable circuit to buzz using those intervals.

The code

The full code is available on my github page. There we have an Arduino sketch that controls the whole clock logic with the help of some additional classes:

emergency_alarm_clock: the main class with all the general logic. It controls the clock modes (clock - alarm - config) and the alarm modes once it's activated (idle - full armed - waiting code - waiting button).
clock: a handler for the clock, retriving and setting the time when needed. It works as a wrapper for some commands using the RTClib library from Adafruit in order to interact with the RTC module via I2C. I also needed to write a function to access the alarm current time data from the clock, since the RTClib library doesn't seem to have this functionality (or at least I didn't see it!).
two_keys: the class responsible for checking the state of each of the key switches. The time between "key turns" is set and controlled here, among with the multiples states of this particular module.
keypad: all the keypad stuff goes here, from the code state machine (waiting for the correct code) to the different buttons the user can press while in config mode.
off_leds: an aux class to handle the green leds indicating which modules are currently de-activated.

The box

Once everything was working properly, it was time to build a nice box for the clock. I designed it using Fusion 360 and it was one of my first "big projects". Then I 3D-printed it, glued some parts, sanded, painted and put it all together.

I also printed some minor parts first to make sure the spaces, holes and sizes were correct and all the elements could be attached without any problem:

As a reminder for myself, designing the box to avoid the screws on the top-side of the box maybe wasn't the best idea since now there's a small gap between the front and the other walls (everything holds together using the bottom screws and nothing else). I probably won't redesign it for now, but that's a lot of feedback I'll definitely use for the next project.

Using the clock

So, the clock displays the time, that's nice!

In clock mode:

Holding 0 changes between AM/PM and 24h mode (this feature resets every time the Arduino is powered off). In AM/PM there's a small dot on the first digit to mark the AM hours - this dot will change to the second digit for the PM hours.
Holding # enables or disables the alarm (this feature resets every time the Arduino is powered off). When the alarm is activated a small dot appears on the last digit.
Holding * activates the config mode.

Once entering the config mode the user can swap between setting the current time or the alarm time. When setting the current time there'll be two dots on the first two digits; when switching to the alarm, those dots will be in the last two digits. The config mode changes the clock to 24h mode.

1/4 to increase or decrease the hours on the selected time.
3/6 to increase or decrease the minutes on the selected time.
2 to change between current time or alarm time.
0 to exit the config mode without saving anything.
# to save the current selected time and exit the config mode (that means you'll need to enter the mode twice if you wanna change the current time AND the alarm time, since only the "visible one" is the one actually saved).

See it in action

Improvements, future changes, ideas...

I have no plans to continue with this project but here there're some annotations and thoughts about future improvements:

More modules!
Make a better user interface when accessing the config mode (now it's kinda confusing).
Maybe it could be nice to try to fit the whole project into a small Arduino?
A new box with better design.
Improve the buzzer?
Add some external port for the alarm ouput pin so I can attach whatever I need in that moment to trigger it instead of using only the "inside mechanism".

Links, references...

Special thanks to my friends Jorge and Sofia for the text review and grammar corrections.