This document describes the design and implementation of a smartwatch prototype using inexpensive, commonly available components. Key features included are a touchscreen LCD for display and input, Bluetooth module for communication with a smartphone, and a wireless charging system for the battery. The prototype demonstrates the integration of these technologies and serves as a proof of concept for a basic smartwatch. Challenges encountered included inefficient screen updates, modifying Bluetooth code for notifications, and addressing differences in the charging module and Arduino voltages. The completed prototype functions as a basic smartwatch, displaying time and notifications from a paired phone.

1. 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. 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. 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. 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. 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. 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. 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].