## Introduction: The Ultimate Binary Watch

I recently got introduced to the concept of binary watches and started doing some research to see if I could build one for myself. However, I was unable to find an existing design that was both functional and stylish at the same time. So, I decided to create my own design completely from scratch!

## Supplies

All of the files for this project:

The libraries for the Arduino code can be downloaded from GitHub here:

M41T62 RTC Library

FastLED Library

LowPower Library

## Step 1: The Idea!

I recently stumbled upon the following video:

DIY Binary Wrist Watch

The video above shows a basic homemade binary watch. I had no idea that such a thing existed but after doing some further research into the topic of binary watches I quickly realized there were a ton of different designs out there! I wanted to build one for myself but was unable to find a design that I liked. The binary watches that I found were lacking a lot of features and did not look particularly good. So, I decided to design my own completely from scratch!

The first step was establishing the criteria for my design. This is what I came up with:

• Binary RGB interface
• Time display (with very accurate timekeeping)
• Date display
• Stopwatch functionality
• Alarm functionality
• Battery life of at least 2 weeks
• USB charging
• Software easily customizable by the user
• A clean and simple design

These criteria became the foundation for the entire project. The next step was to figure out how I wanted the watch to function!

## Step 2: Some Binary-Watch Theory

The plan was simple. The binary watch would operate just like a regular watch except that the interface would be binary, specifically, BCD (Binary Coded Decimal). BCD is a type of binary encoding where each decimal digit is represented by a fixed number of bits. I need 4 bits to be able to represent a digit from 0-9. And for a standard `hh:mm` time format, I need 4 of those digits. This means that I need a total of 16 bits which will be represented by 16 LEDs.

Reading the time in BCD is pretty easy once you get used to it. The row at the bottom of the watch represents the least significant bit (1) and the row at the top is the most significant bit (8). Each column represents a digit in the `hh:mm` time format. If an LED is ON, you count that value. If an LED is OFF, you ignore it.

To read the first digit simply sum all the activated LEDs corresponding values in the first (left most) column. Do the same for the other digits from left to right. You have now read the time in BCD!

This principle will be the same for the rest of the functions on the watch. The use of RGB LEDs will help distinguishing between different functions and modes using different colors. The colors are chosen by the user and can easily be adjusted to whatever color palette they prefer. This allows the user to easily navigate through the functions without getting confused.

The next step was creating a block diagram!

## Step 3: Getting to Work

As any typical electronics project, a block diagram is an essential part in the early design stage. Using the criteria, I managed to put together the block diagram above. Each block in the diagram represents a function in the circuit and the arrows show the relationship of the functions. The block diagram in its entirety gives a good overview of how the circuit is going to work.

The next step was to start making decisions on individual components for each block in the block diagram!

## Step 4: Choosing Components

There turned out to be quite a lot of components in this circuit. Below, I have picked out some of the most essential ones together with an explanation on why I chose them.

### The LEDs

For the binary interface, the choice was fairly straight forward. I knew that I wanted to use LEDs for the display and figured out that I needed 16 of them (in a 4×4 grid) to display as much information as possible. During my research for the perfect LED, the APA102 kept coming up. It is a very small (2mm x 2mm) addressable LED with a wide range of colors and is fairly inexpensive. Even though I had never worked with them before, they seemed to be the perfect fit for this project, so I decided to use them.

### The Microcontroller

The choice of a microcontroller was also pretty simple. I have had a lot of experience using the Atmega328P-AU in standalone applications and was very familiar with its features. This is the same microcontroller that is used in the Arduino Nano boards. I am aware that there probably is a cheaper microcontroller that I could have used but knowing that the Atmega328 would have full support for all Arduino libraries was a big factor in choosing it for this project.

### The RTC (Real-Time Clock)

The primary requirement for the RTC was accuracy. I knew that the watch would not have any internet connectivity and thus would not be able to recalibrate itself via an internet connection, the user would need to recalibrate it manually. Therefore, I wanted to make the timekeeping as accurate as possible. The M41T62 RTC has one of the highest accuracies that I could find (±2ppm which is equivalent to ±5 seconds per month). Combining the high accuracy with the I2C compatibility and the ulta low current consumption made this RTC a good choice for this project.

### DC-DC Boost Converter

Choosing the DC-DC Boost Converter IC was done simply by looking at the circuit and figuring out what voltages and currents were required. Running the circuit on a low voltage would decrease the current consumption but I could not go below 4.5V (the minimal microcontroller voltage at 16MHz clock) and I could not go above 4.5V (the maximum voltage of the RTC). This meant that I had to run the circuit at precisely 4.5V in order to operate the components within their recommended specifications. I calculated that the maximal current of the circuit would not exceed 250mA. So, I began looking for a boost converter that could meet the requirements and quickly stumbled upon the TPS61220. The TPS61220 required minimal external components, was fairly inexpensive and was able to satisfy the current and voltage requirements.

### The Battery

The primary requirement for the battery was the size. The battery needed to be small enough so that it could fit inside the watch enclosure without making it look bulky. I figured that the battery could not exceed 20mm × 35mm × 10mm. With these size constraints and the current requirement of 250mA my choice of batteries was limited to LiPo batteries. I found a "Turnigy nano-tech 300mAh 1S" battery on Hobbyking which I decided to use.

### The Charging IC

There was no particular requirement for the charge controller except that it needed to be compatible with a 1S LiPo battery. I found the MCP73831T which is a fully integrated charge controller designed for single-cell charging applications. One of its features is the ability to adjust the charging current through an external resistor which I found rather useful in this application.

### LiPo Protection

I wanted to include voltage and current monitoring to protect the battery from any dangerous overcharge and over-discharge conditions. There were a limited amount of ICs that provided such features and one of the cheaper options was the BQ29700 IC. It required a minimal amount of external components and included all the necessary protection for a single-cell LiPo battery.

Now that the components were chosen it was time to create the schematic!

## Step 5: The Schematic

I was able to put together the schematic above using recommendations from each of the component’s datasheets. The schematic is divided into different blocks to make it more readable. I also added some notes with important information in case anyone else would want to recreate this design.

The next step was laying out the schematic on a PCB!

## Step 6: PCB Layout

The PCB layout turned out to be the most challenging part of this project. I chose to use a 2-layer PCB to keep the PCB manufacturing costs to a minimum. I opted to use a standard watch size of 36mm because that seemed to fit the LEDs pretty well. I added some 1mm screw holes to secure the PCB in the watch enclosure. The goal was to maintain a clean and good-looking design by placing all of the components (except the LEDs of course) on the bottom layer. I also wanted to use the absolute minimal number of vias to avoid having visible vias on the top layer. This meant that I had to route all of the traces on a single layer while making sure to keep the "noisy" parts of the circuit away from the sensitive signal traces. I also made sure to keep all of the traces as short as possible, placing the bypass capacitors close to the load, using thicker traces for high power components and otherwise follow all of the common good practices of PCB design. The routing took quite a bit of time, but I think it turned out very well.

The next step was creating a 3D model for the watch enclosure!

## Step 7: 3D Design

The watch enclosure was designed after a very conventional watch style. I used a standard 18mm spacing for the watch strap to make the watch compatible with a large variety of other straps. The cut-out for the PCB was designed 0,4mm larger than the PCB itself to accommodate for any manufacturing inaccuracies. I included some screw posts for mounting the PCB and a small edge for the PCB to lay on. I made sure to recess the PCB a fem millimeters from the top to avoid the sharp edges of the LEDs getting stuck on clothing. The height of the enclosure was solely determined by the thickness of the battery. The rest of the enclosure was designed to simply look good with rounded edges and polished corners. I did have to keep the design 3D-print friendly so that I could 3D-print it at home without any support material.

Now that the hardware was finished it was time to begin working on the software!

## Step 8: The Code

I began the code by including all of the necessary libraries. This includes the library for communicating with the RTC and for driving the LEDs. After that, I created separate functions for each of the modes. When the user switches modes by pressing a button, the program calls on the function corresponding to that mode. If the user does not press a button within a specified amount of time, the watch goes to sleep.

Sleep mode is indicated by all of the LEDs fading until they are completely off. Using the sleep mode greatly increases the battery life and keeps the LEDs turned off when they are not in use. The user can wake up the watch by pressing the upper button. When woken up, the watch will check the battery level to ensure that it does not require charging. If charging is required, the LEDs will flash red a few times before displaying the time. If the battery is below a critical level, it will not turn on at all.

The rest of the time programming went into making the other modes as intuitive as possible. I figured that having the same button responsible for the same functionality across all modes would be the most intuitive. After some testing, this is the button configuration that I came up with:

• Top Button Press: Wake up / Cycle between "Display Time", "Display Date", "Stopwatch" and "Alarm" modes.
• Top Button Hold: Enter "Set Time", "Set Date", "Start Stopwatch" or "Set Alarm" mode.
• Bottom Button Press: Increase Brightness.
• Bottom Button Hold: Enter "Choose Color" Mode.

The bottom button is always responsible for the brightness and color adjustments, independent of what mode you are in. When the user enters "Choose Color" mode, the LEDs start cycling through all of the possible RGB colors. The user can pause the animation and choose the color that they prefer for that specific mode (Display Time in red, Display Date in blue, etc.). The colors are meant to be easily customizable by the user to help them distinguish between the different modes.

Now that the code was finished it was time to upload it to the microcontroller!

## Step 9: Programming

It was almost time for the soldering and assembly but before that I needed to program the microcontroller. I followed this tutorial

Burn the bootloader to a ATmega328P-AU SMD

on how to burn a bootloader and program the microcontroller using a regular Arduino Uno as the programmer.

The first step was to turn the Arduino Uno into an ISP by uploading the "ArduinoISP" example code. I used a breadboard together with a programming socket and wired up the schematic from the tutorial. After that, I was able to burn the bootloader to the microcontroller by just pressing "Burn Bootloader" in the Arduino IDE.

Once the microcontroller had a bootloader, I simply removed the existing microcontroller from the Arduino Uno and used the Arduino Uno board as a USB to Serial Adapter to upload the code to the microcontroller in the programming socket. After the upload was finished, I could begin the soldering process.

The next step was gathering all the components and soldering them together!

## Step 10: Soldering

The soldering process was divided into two parts. First the bottom layer needed to be soldered, and then the top layer.

I secured the watch PCB between a couple of prototype boards using tape. This ensured that the PCB did not move during soldering, which is very important. I then placed the soldering stencil over the PCB and used a generous amount of solder paste to cover all of the solder pads. I proceeded to use a thin pair of tweezers to place all of the components on their corresponding pads. I then used a heat gun to reflow solder all of the components in place.

When the bottom layer was soldered, I gave it a quick visual inspection to make sure that the soldering was successful. I then flipped over the board and repeated the soldering process on the other side, this time with all of the LEDs. It was very important to not overheat the board when soldering the top layer since all of the components on the bottom are at risk of falling off. Thankfully, all of the components stayed in place and after soldering the buttons in place using a regular soldering iron, the PCB was finished!

It was now time for the final assembly!

## Step 11: Assembly

The assembly was very simple. I connected the battery to the PCB and placed the battery and the PCB inside the 3D printed enclosure. I proceeded to screw in the four screws in the mounting holes in each corner of the PCB. After that, I attached the watch straps using the 18mm spring bars and the watch was complete!

## Step 12: Conclusion and Improvements

The watch works as expected and I am very happy with how it turned out. I have not had any problems with it so far and the battery remains almost fully charged after a whole week of use.

I might add other features to the watch in the future. Since the USB port is connected to the microcontroller, the firmware can be updated at any time with new features. For now though, I will continue to use this version of the watch and see how it holds up after extended use.

If you have any thoughts, comments or questions about this project, please leave them below.