1

Abstract—This experiment provides a working prototype of a

smartwatch using inexpensive, commonly found components.

The device consists of an LCD with touch-input capability for the

user, a Bluetooth module to connect and communicate to the

user’s mobile device, and a battery system that extends battery

life with the ability to be charged wirelessly. Designing this

system provides the authors with the opportunity to work with

the integration of software and hardware, and create a device

that combines the aforementioned technologies in a working,

proof-of-concept computer system. Furthermore, the experiment

provides the opportunity to research existing and future

technologies that could be applied to this prototype to bring a

product to market.

I – INTRODUCTION

URRENTLY, there exists a large barrier to entry in the

smartwatch market. Proprietary technology and licensing

deals with OEM’s make the design of a compact, complete

smartwatch very difficult. Larger components are used in the

design as smaller customized components would require prior

knowledge of desired pinouts, communication protocols, and

planned schematics. The larger breakout board components

also provide freedom to interchange components and

experiment with different hardware designs to find the optimal

setup. Furthermore, the physical materials required to create a

complete watch (leather/metal band, links, glass, etc.) are not

readily purchased and assembled. For these reasons, we

decided that the best approach to this problem would be

development of a prototype device that combines a few core

features commonly found in current smartwatch devices.

In our prototype, we implemented three core features: a

touch LCD, Bluetooth communications, and wireless charging

for the battery. Upon completion of implementing these

features, we have a working platform to build from if time

permits. These features alone comprise a basic computer

system: a controlling unit with a data path, a user interface,

and a means of communicating to external systems. With core

functionality in mind, the design process actually allowed us

to perform a lot of research into both current and future

technologies relevant to the various fields.

The design carries out as a parallel process. With three team

members and three core functions to implement, each member

works individually on an assigned component, with periodic

meetings to facilitate the integration of the three into the final

system. The LCD is programmed and calibrated to perform

the functions necessary of a watch face, the Bluetooth module

is tested and set up to work with the microcontroller to be able

to connect and communicate with a paired handheld device,

and the battery requirements for the system are calculated and

implemented.

This project is valuable to us for multiple reasons. First and

foremost, it is a project that is feasible to complete in about 7-

8 weeks of limited time, and provides us with an opportunity

to learn about different engineering disciplines and combine

them into a computer system, and it is always good practice to

work with new and emerging technologies to keep engineering

skills current. Much of modern engineering design requires

analysis of datasheets, application notes, pieces of code, etc.,

which are important skills to have. Furthermore, the various

components being implemented in the system come from

different fields of electrical engineering. These fields include

microcontroller programming, power electronics, Bluetooth

communications, and mobile software development. Beyond

that, our research led us to understand how our prototyped

system could be improved in the future.

II – COMPONENT DESIGN

This design combines readily available components into a

system that performs three core functions commonly found in

commercial smartwatches. The primary system functions

include capacitive touch input, displaying of time and date,

and notifications of messages received on a paired Smart

Phone device. The Bluetooth protocol is used to facilitate

communications between the system and a mobile device.

The design of the system is broken down into three distinct

sections, including a display module, Bluetooth module, and

wireless charging module as shown in Figure 1.

Fig 1. Components included in prototype smart watch design.

The controlling unit is an Arduino Uno microcontroller, and

it interfaces seamlessly with the Bluetooth Low Energy Shield

for Arduino and the Adafruit TFT Touch Shield for Arduino

to form the core of the watch electronics. A battery system is

used to power the Uno (which connects power and ground

pins of all three boards, thus powering them all) to allow for

Smart-Watch Prototype

Charlie Aylward, David Ritter, and Eric Rule

C

2

mobility. The Arduino UNO contains the MCU controlling the

rest of the system by the means of SPI and I2C

communication protocols. The Arduino UNO serves as an

ideal prototyping main controller as it provides a large array of

digital and analog pinouts which can behave as inputs and

outputs. The Arduino UNO also provides the other system

components with a power source.

Fig 2. Arduino UNO with labeled headers for connections to

added modules.

A – LCD Module

An Adafruit capacitive-touch LCD screen provides an

interactive user interface. The screen is 2.8”, has a 240x320

resolution, and utilizes 16-bit color [1]. It communicates with

the Uno via SPI, runs off 3.3V, and draws approximately

100mA when updating [1]. Most important are the basic watch

functions of displaying the time and date. These are found at

the top of the screen, and are updated as often as possible.

The rest of the screen is reserved for displaying incoming

notifications, sent via Bluetooth from a paired mobile device,

usually a smartphone. When the watch receives a notification,

the microcontroller processes it and displays the correct

message to the user.

This LCD is much larger than would be necessary on a real

smartwatch, and as such, would be replaced in the future.

Reducing the size of the screen would not only reduce the

overall power consumption of the device, but also allow for

greater utilization of the screen. Some choices that would be

considered when choosing a screen technology such as LCD,

AMOLED, or e-paper would be pixel density, various

color/brightness/contrast attributes, and power consumption.

The e-paper screen is dim and plain, but consumes an

incredibly small amount of power, allowing for greater battery

life. Deciding between LCD and LED technologies would be

a matter of pricing and performance.

B – Bluetooth Module

The RedBearLab BLE board is connected to the Arduino

Uno for the prototyping of this system, and it contains the

necessary hardware to implement a fully functioning

Bluetooth module. It supports multiple operating systems and

Bluetooth protocols [2]. The purpose of this board is to allow

Bluetooth communication pairing between the system and a

user’s smartphone, to receive useful data from it. To complete

this transaction of data, the Arduino software is configured to

wait for data once a device is paired. When it receives a

signal indicating some useful data has been transferred, it

communicates to the Uno via ACI [2], which is a modified

version of SPI, to have the data processed accordingly. For

instance, if the user receives an email on their phone, the

notification is sent over Bluetooth to the BLE board, and then

to the Uno, where it processes the notification and displays the

correct graphic on the LCD.

To distinguish between different types of notifications

received by the phone, some software must be installed. For

this project, the Android OS by Google is supported (in the

future, Apple’s iOS would also be supported) and an Android

application must be installed to facilitate communication. The

Android application requests to pair with the smart watch

prototype, and sends the correct information to the BLE board

once paired. Figure 3 illustrates the packet flow between the

smart watch and a connected smart phone. This custom

Android software is partially taken from some open source

code found on the Internet, but has been modified for custom

use.

Fig 3. Bluetooth pack flow diagram between prototype smart

watch (RX) and connected Android smart phone (TX)

Currently, the prototyped system allows for email, text

message, and call notifications. In the future, support for more

functionality would be implemented on both ends, such as the

ability of the watch to send various sensor data to the paired

phone. Beyond that, the Android application would be

substantially updated to provide a more comprehensive

interface.

C – Battery Module

There are multiple constraints to consider when running an

embedded system off battery power. The battery must have

sufficient voltage to keep all circuits running simultaneously,

and account for supply drops at times of high current draw at

peak operation. The amp-hour capacity of the battery must be

3

more than enough to allow the device to run for a desired

amount of time to prevent unwanted shut-offs due to power

consumption. Furthermore, the battery must be physically

sized to fit in the packaging that will be used to house the

device. These constraints require analysis of device power

consumption at different periods of operation: low-current

draw “idle” state and peak current draw when the user is

operating the device frequently. The manufacturer of the

microcontroller used in this design recommend a battery

voltage range of 7V to 12V. The lower bound of 7V is

required to prevent the 5V traces from dropping too low and

the upper bound prevents a voltage regulator from overheating

and burning up. The first instinct is to jump to a 9V battery as

the solution; however, the 9V cells generally have low

capacity, and a lot of its energy will be burned off as heat

being dropped to the lower voltages required by the controller.

Since the battery must also be wirelessly rechargeable, this

eliminates the choice of any standard store-bought cells.

Herein lies the issue of barrier to entry: without integrating

the necessary components into a single, compact system (as

done in modern smartwatches), the battery will be much larger

than it would actually need to be. Many smartwatches

currently available use small, efficient rechargeable batteries:

an iFixit teardown revealed that the Apple Watch uses a 3.8V,

205mAh lithium-ion battery [1], and the Samsung Gear Live

uses a 3.8V, 300mAh lithium-ion battery [2]. These batteries

are allowed to be so compact because the rest of the circuitry

is optimized for the device and there are no unnecessary

components. Our project, being a prototype, will not be nearly

as efficient, and a 9V rechargeable cell will be sufficient as a

proof-of concept.

To charge the battery wirelessly, a simple set of inductive

coils with charging circuitry was purchased from Adafruit, and

are used to recharge the battery. This coil supplies 0.5A at

max power transfer, and as such is not an ideal charging

system. The Apple watch has a receiving coil and charging

circuitry built into the device [1] and greatly simplifies the

wireless charging of its battery.

If this design were to be taken further and improved to the

point of being viable as a consumer good, the battery system

would change drastically. First of all, if the entire system was

optimized to fit in a single housing, the battery could be

reduced to a much smaller size, most likely one of the

common 3.8V solutions. The wireless charging kit would be

optimized to support one of the current standards being

developed (PMA, WPC, A4WP) and reduce in size, while

being able to supply a higher current such as 1A.

III - SYSTEM ARCHITECTURE

The Arduino UNO serves as the system’s main controller,

keeping track of connected devices and running the code,

which provides the system with functionality. The Arduino

UNO was a good fit for our needs as it offers multiple

communication protocols and an abundance of digital and

analog IO pins for adding devices. Along with the hardware

benefits of the Arduino UNO, there are easy to use code

libraries available for software development. Many attachable

devices have manufacturer-developed API meant to interface

the device with Arduino systems. Both the RedBearLab BLE

Shield and the TFT LCD display offer example code and

libraries for the Arduino UNO simplifying the software

development process.

Fig 4. System Component Setup showing connection methods

for RedBearLab BLE Shield and TFT LCD Screen.

The primary functionality for the prototype device includes

time display, Bluetooth notifications, and wireless battery

charging. Both time keeping and Bluetooth communication

rely heavily on the software for correct operation. Bluetooth

notifications specifically require a separate device such as a

smart phone for the intended functionality. The goal of this

project is to pair the prototype with an Android smart phone.

The Android Operating System was chosen as it allows open

source development. Communication with a smart phone

requires that the phone have software enabling it to function

properly. Smart phone applications serve this purpose and can

also grab system information from the phone, such as

notifications. With an application on the smart phone, the

smart watch prototype system can successfully receive

notifications from the connected smart phone via Bluetooth.

Figure 5 shows the system block diagram with the smart

watch modules and the Bluetooth-connected Android

smartphone.

Fig 5. Block diagram of system design and system interfaced

with Bluetooth compatible Android smartphone.

The software development process involved two main parts.

4

First, the Arduino microcontroller required the necessary code

to keep track of time, communicate with the Bluetooth shield,

and communicate with the touch screen display. Second, an

Android application able to pull notifications from an Android

smart phone and establish a connection with the Bluetooth

shield on the prototype needed to be developed. The time

keeping software utilizes the Arduino Time library. More

specifically, the function “millis()” is an Arduino method that

keeps track of the milliseconds after the initialization of the

program code once loaded onto the Arduino. By setting the

initial time in the code and using the Time functionality

mentioned, the Arduino is able to serve as a clock. Using the

TFT LCD display, the time can be output to the screen in a

readable format showing the current time (up to seconds) and

date.

Software needed for communication with the RedBearLab

Bluetooth shield and the Adafruit TFT LCD display was

available in libraries from the respective manufacturers. This

made the initial task of establishing connections simple and

left only the programming toward our specific application.

The Bluetooth shield did not require much initialization code

beyond setting the broadcast name. With the name established,

a single function calls begins the operation of the Bluetooth

shield. Once in “operating mode”, another function call polls

for devices requesting to be paired. Once paired, a separate

function checks for data being sent along the connection

toward the BLE shield. In this system, the Bluetooth

transmission is unidirectional from the phone to the BLE

shield. This setup is appropriate, as the prototype device only

needs to receive Bluetooth information from the smart phone.

If a notification is received over Bluetooth by the BLE shield,

the microcontroller draws an indication graphic to the display.

The interfacing to the TFT LCD display also requires minimal

setup. The initialization involves drawing a background to the

screen and creating the time display. After initialization, the

display shows notification graphics and updates the time when

triggered. Figure 6 shows the system’s software workflow.

Fig 6. Software flowchart for the Arduino UNO

microcontroller interfaced with the Bluetooth shield and TFT

LCD display.

IV – DISCUSSION OF RESULTS

The working smartwatch prototype implements the three

discussed functionality of LCD display, Bluetooth

communication, and wireless charging for only $112.79 (see

Appendix for BOM). While the user interface is primitive in

design and functionality, the smartwatch displays the time and

integrates Capacitive Touch functionality for changing the

color of the Bluetooth notification icon. The Bluetooth

communication is demonstrated with email notifications

displayed to the LCD screen from an external Android phone

(via a user created Android application). The wireless

charging is integrated via a 3.3V LI battery that drives the

entire Arduino based smartwatch system. Overall, the system

behaves as discussed in the System Architecture section, and

integrates the three components. A few of the issues

encountered during implementation of the prototype follow.

5

A – Challenges with the LCD

The sample code found on the Ardiuno website for the

Capacitive Touch LCD display requires explicitly writing to

each pixel or group of pixels on the LCD. Therefore each time

the time display is updated, the previous time (or anything on

the display) must be written over to erase the previous display.

Because the sample code is not optimized, the writing and

rewriting of something even as small as the time bar must be

locally erased. The update or “loop” cycle cannot update fast

enough for the Bluetooth and erasing the entire display every

cycle. This bug was fixed by locally erasing the changes to the

display rather than continuously refreshing the entire display

buffer (erasing the entire display and rewriting to all the

pixels).

B – Challenges with Bluetooth

The Arduino Bluetooth sample code found online utilized an

Android application for communication with the Arduino BLE

shield. However, the application originally required user input

to change a set of LEDs. This code was modified to first

display a notification and then access the Android notification

outputs to trigger a display sequence (i.e. to display an icon on

the LCD). The internal Android email notification flag

required modifying the Android application to accept email

notifications. This required both access permission on the

Android operating system and integrating the notification to

trigger the LCD icon display via Bluetooth.

C – Challenges with Wireless Charging

The wireless charging module purchased from Adafruit

requires a 9V source [5] (battery or external power supply)

and outputs the same 9V on the load side. However, the

Arduino runs on an internal 3.3V and can be driven off of a

USB power of 5V. Furthermore, the LI battery used is 3.7V.

The power electronics used to integrate the system included:

1) 9V battery/PS to Wireless Charging TX

2) Wireless Charging 9V TX to Wireless Charging 9V RX

3) Wireless Charging 9V RX to Buck Convertor Input

4) Buck Convertor output (5V) to

USB Battery Input Module (5V)

5) USB Battery Input Module (5V) to LI Battery (3.7V)

6) LI Battery (3.7V) to USB Battery Output Module (5V)

7) USB Battery Output Module (5V) to

Arduino USB Power Input (5V)

8) Arduino USB Power Input (5V) to

Arduino Power Input (3.3V)

The complexity of the power electronics and stepping down,

then down, then up, then down requires more voltage

conversions than necessary. However, for fast prototyping and

with the available components, the complexity of the power

electronics was necessary. Future implementations would

include simplifying the conversions or at least localizing the

conversions on board (rather than through external modules).

D – Further Implementations

The physical prototype only implements the three discussed

main functionality, but serves as a spring board for future

implementations. The two main future goals are system

optimization and additional functionality.

To optimize the system further, a Bluetooth based System

on Chip (SOC) would be used such as the Broadcom

BCM20737 . This SOC integrates a Bluetooth receiver on-

chip, an ARM processor, and internal RAM [6]. While the

RAM may not be sufficient to drive the current LCD, an

external GPU/frame buffer could be used especially for a

smaller display with optimized library code. A Bluetooth SOC

would be the ideal solution because of the localized Bluetooth

receiving and transmitting along with the decrease in overall

system size. The BCM20737 also integrates battery

management software capable of monitoring wireless charging

[6] which further proves the worth of such a solution.

The main additional functionality would fall under either

software of hardware. Improved software functionality would

include and improved user interface and additional

applications. The user interface, like the Apple Smartwatch

[4], would include a main menu for application selection.

Then the smartwatch would display the selected applications

interface and remain in the application until a user input return

indication is made. Added applications could include a

notepad (with capacitive touch), calendar, heart rate monitor

(via hardware blood-pulse indicator), picture viewer, media

player, and potentially an internet web browser (requiring

WIFI compatibility).

Additional hardware peripherals would include a

microphone, speaker, gyro, accelerometer, WIFI chip, blood-

pulse monitor (on rear of smartwatch), and vibrator (resonant

actuator). The hardware peripherals would input to the main

microcontroller and be accessed based on the current

application. The current smartwatch prototype is simply a

platform for many possible applications via sensors and

displays. Almost any application (and more) run on a phone

could be run on a smartwatch. However, the size constraint on

a smartwatch is smaller than for a smart phone. The

implementation of any of these applications using sensor

inputs requires a cost-benefit business analysis.

V – CONCLUSION

In this experiment, a smartwatch prototype is created using

inexpensive components in a short timeframe (less than 10

weeks). The prototype has three main components of LCD

6

display, Bluetooth communication, and wireless charging.

These three components comprise a base requirement for a

smartwatch with the intention that further improvements

would be made before any final product. This proof of concept

approach is used to show that with minimal time and money a

smartwatch prototype can be created. The system is Arduino

based so the software and hardware integration required less

time to create than a more optimized system. The price of the

system prototype is only $112.79 which is low considering the

development boards are not optimized. This smartwatch

prototype shows that a smartwatch can be implemented with

little time and money, but the system is far from optimized

and lacks certain functionality to compete with current on the

market competitors. Overall, the barrier to entry to the

smartwatch market is high because of the necessary

optimization to compete with current products. So any final

smartwatch product would require significantly more time,

money, and expertise to accomplish.

7

Appendix

References

[1] Adafruit, “TFT Touch Shield” 2015. [Online] Available:

http://www.adafruit.com/products/1651 [Accessed 14 May

2015].

[2] RedBearLab, “BLE Shield” 2015. [Online] Available:

http://redbearlab.com/bleshield/ [Accessed: 16 May 2015].

[3] iFixit, “Apple Watch Teardown” 23 April, 2015. [Online]

Available:

https://www.ifixit.com/Teardown/Apple+Watch+Teardown/4

0655. [Accessed: 18 May 2015].

[4] iFixit, “Samsung Gear Live Teardown” 8 July 2014.

[Online] Available:

https://www.ifixit.com/Teardown/Samsung+Gear+Live+Teard

own/27038#s66770 [Accessed: 18 May 2015].

[5] AdaFruit, “Inductive Charging Set” 2015. [Online]

Available: http://www.adafruit.com/products/1407 [Accessed:

4 June 2015].

[6] Broadcom, “Low-Power Bluetooth 4.0 Single-Chip, BLE-

Only SoC With Wireless Charging, NFC And RSA Security”

2015. [Online] Available:

https://www.broadcom.com/products/wireless-

connectivity/bluetooth/bcm20737 [Accessed: 4 June 2015].