Turn an Old Cell Phone Into a Smartwatch

Smartphones are an integral part of our everyday lives, but remember when they were not so
smart? Those golden days when push-button monochrome LCD screened phones did little more
than call? I'm sure a lot of us still have some of those old dumb phones lying around. And you're
probably wondering...what can I do with it now? What if I told you that you could turn that old cell
phone into a smartwatch!?! Keep reading to find out how!
Not much for reading? Feel free to watch the playlist below instead!
Step 1: Scavenging Parts

What Id like to do for this crazy/ambitions project is turn an old cell phone into a smartwatch. So
obviously an old cell phone is required. The primary reason for this project is simply that I had an
old cell phone laying around and wanted to find a creative way to repurpose it. The one I had is a
Nokia 1100, but most other old cell phones would work, so long as you can find the schematics for
the LCD online. Taking apart the 1100, there werent too many scavenge-able parts to choose from.
First and foremost, there was the LCD screen, then I was also able to extract a vibrating motor, a
small speaker, as well as a protective cover for the LCD. What youre able to scavenge really
depends on what type of phone you have, and how old it is. The older the phone, the more
scavenge-able parts you will find.

Step 2: Repurposing the LCD

Without a working LCD, we have no project, so I need to figure out how to get it working outside
of the phone. The first step is to see if I can find a schematic for it online. Doing a search for Nokia
1100 LCD, I was able to find out a ton of information about it. I found that the LCD model number
is PCF8814. I was also able to find a schematic that listed the pinouts.
This is a view from the back side of the LCD, so Pin 8 is on the far left when looking at the back.
There are 9 pins, but one is unused, leaving 8.
1. LED (Positive 3.3v)
2. VDD
3. VDDI
4. SCLK
5. SDA
6. GND
7. CS
8. RES
The pins on the LCD are very small, so in an effort to make them easier to connect to, I soldered
wire from a ribbon cable to each pin, and then hot glued it all into place. So now I can connect each
of the wires to a breadboard to make it easier to work with the LCD.
Step 3: Driving the LCD
Now that I have the LCD ready for connection, I need something to connect it tosomething that
can send text to it for display. The display driver that I chose was the Arduino, primarily because I
can use an Arduino Uno for prototyping, and when Im ready to cram it all into a watch, I can use
the much smaller Arduino Mini. First I connected all the LCD wires to a breadboard, and then I
began connecting wires to the Arduino. I added some resistors to the pins that connect directly to
Arduino pins to keep the Arduino from burning out the LCD. Total, it was 4 x 1.8 kOhm resistors ad
4 x 3.3 kOhm resistors. Use the diagram below for resistor connections, but as far as LCD to Arduino
connections, this is how I connected it:

LCD > Arduino

LED > 3.3v (Moved to Pin 8 for custom on/off control)
VDD > 3.3v
VDDI > 3.3v
SCLK > Pin 13
SDA > Pin 11
GND > GND
CS > Pin 10
RES > Pin 12

Here is the connection diagram:

If you were to power up the Arduino at this point, you should see the backlight come on for the
screen, but nothing will display on it until we add some code, which is what well do in the next
section.
Step 4: Writing to the LCD
The final key to making this LCD work is to program some code into the Arduino that sends text to
the LCD. If I were to write the entire code from scratch, I would have to tell each Arduinopin what
to display, how to display it, when to turn off, etc., which would take forever. Luckily this can be
resolved through the use of libraries. I was able to find a couple of different libraries for the
PCF8114, but I chose this one from Github user cattzalin because of its ability to display bitmaps.
You can download it, unzip it, and then move it to your Arduino libraries folder (check out this guide
for more information). You can then open up the Arduino software and start writing some code.
You can use my code below as reference, but basically I imported the library, set the variables for
the type of screen I am using, and then I sent some text to the screen.

#include

static const byte ledPin = 13;

static const byte LCD_WIDTH = 96;
static const byte LCD_HEIGHT = 65;
 static PCF8814 lcd;

void setup() {
lcd.begin(LCD_WIDTH, LCD_HEIGHT);
pinMode(ledPin, OUTPUT);
lcd.print("The LCD Totally Works!");
delay(5000);
lcd.clear();
}

void loop() {
lcd.setCursor(0, 0);
lcd.print("Visit my website");
lcd.setCursor(40, 1);
lcd.print("at:");
lcd.setCursor(0, 2);
lcd.print("www.tinkernut.com");
delay(5000);
}

Plugin your Arduino, upload the code, and if everything works right, you should see your text on
the screen! Now that we have our LCD functioning, we can move on to the next step!

Step 5: Adding Bluetooth

The magic dust that will turn this LCD screen into a smartwatch is bluetooth. Bluetooth is a wireless
standard that will let the smartphone communicate with the Arduino and send it stuff like time,
date, notifications, etc. I ended up going with a JY-MCU (HC-06) bluetooth module. Its about the
size of the Arduino pro mini. There are smaller options available, but they require surface mount
soldering skills, which I dont really want to get into for this project. Connecting it is pretty simple:
GND goes to Arduino Ground, VCC goes to Arduino 3.3v, TX goes to Arduino RX and RX goes to
Arduino TX. Heres a diagram:
Step 6: Adding the Other Components
There were a couple more hardware features that I wanted to add to the smartwatch: a vibration
motor for notifications, and a button to turn the backlight on and off. To properly wire a DC motor
to an Arduino, it normally requires a transistor, a diode, and a resistor to avoid burning out the
Arduino and/or the motor. But since this is a very small motor with very small voltate, and I very
little space for it, Im just wiring it directly to the Arduino Pin 3 and GND as seen in the diagram
below. The last element I added was a momentary switch button wired to Pin 2 and GND of the
Arduino.
Step 7: Updating the Arduino Code

In Our last bit of Arduino code above, we created a basic splash screen to display characters to the
LCD. This time we want to expand the code to give it functionality in response to what the
Smartphone sends it through bluetooth. You can find a copy of the code below. Youll notice at the
top of the code, where the variables are declared, there are a few variables with lots of characters
in them. These are actually coded versions of images. To create the coded version of an image,
youll need a black and white image and youll need to make sure its sized to within the resolution
of your screen and saved as a bitmap file format. For my screen its 96 pixels by 65 pixels. Then you
can download a free image conversion program called LCD Assistant. Just load the image into the
program and save the output. You can then use that output in your code.
Ive commented the code to try and explain how it works and whats going on, but basically in the
setup section, it displays a splash screen with a logo and text and then resets the screen. In the
loop section, it watches the serial console (bluetooth) for input. In the next step, youll see that the
Android phone is sending a text string through bluetooth in this format:

date | time | phone | text \n

So the code starts by reading the string up until the first | divider and stores it as a variable
(myDate). Then it does the same thing with time (myTime), phone (myPhone) and text (myText).
Now that each section is stored as a variable, we can see what the variable holds and determine
whether to display it to the screen or not. For instance, with the myTime variable, if it equals time,
then that means the Android phone hasnt updated it with the actual time, so we can either display
a comm error or nothing at all. However, if the variable equals something like 12:00:00 PM, then
the Android phone has updated it with the time and we can display that on the screen. Then at the
end of the code, we have the section to make the button work, as well as a backlight loop to keep
the backlight on for a set period of time.

/*******************
* This code requires the PCF8814 library found here:
* https://github.com/cattzalin/Arduino-library-nokia-1100-lcd--PCF8814
*
* This Arduino program is intended to be used as a smartwatch
* using parts from a Nokia 1100 cell phone. It will only work in
* conjunction with the Android app that you can find here:
*
* For more details on how to create your own smartwatch,
* you can visit this website:
* http://tinkernut.com/4keCX
*/

//IMPORT THE PCF8814 LIBRARY (USE LINK ABOVE)

#include

//DECLARE VARIABLES FOR THE LCD

static const byte ledPin = 8;
static const byte LCD_WIDTH = 96;
static const byte LCD_HEIGHT = 65;
static PCF8814 lcd;

//DECLARE VARIABLES FOR OTHER COMPONENTS

const int pwm = 3 ;
int lcdCount = 20;
const int btnPin = 2;
int held =0;
int restart=0;
int buttonState;

//CREATE AN IMAGE FOR INCOMING CALLS

//(USE LCD ASSISTANT TO CONVERT IMAGES TO CODE)
static const byte ph_15 [] = {
0x3C, 0xFE, 0xFF, 0xFF, 0x1E, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x03, 0x07, 0x0F, 0x1E, 0x3C, 0x38, 0x70, 0x70, 0xF0, 0xF8, 0xFC, 0xF8, 0x78, 0x30
};
static const byte PHONE_WIDTH = 16;
static const byte PHONE_HEIGHT = 16;

//CREATE AN IMAGE FOR INCOMING TEXTS

static const byte txt_ico [] = {
0xF0, 0xE4, 0xCC, 0xDC, 0xBC, 0x3C, 0x7C, 0xFC, 0xFC, 0x7C, 0x3C, 0xBC, 0xDC, 0xCC, 0xE4, 0xF0,
0x1F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3E, 0x3E, 0x3E, 0x3E, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x1F
};
static const byte TEXT_WIDTH = 16;
static const byte TEXT_HEIGHT = 16;

//CREATE A SPLASH SCREEN IMAGE

static const byte tinkerwatch [] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x20, 0xE0, 0xF0, 0xF0, 0xF8, 0xF8, 0xF8, 0xFC, 0xE0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xE0,
0xE0, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFC, 0x8C, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0xC0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0xF0, 0xF0, 0xE0, 0xC0, 0xC0, 0xC0, 0xE0, 0xF0,
0xF8, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x7F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x7F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x1E, 0x1C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0F, 0x0F, 0xEF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x7F, 0x1F, 0x0F, 0x07, 0x03, 0x01, 0x00, 0xC0, 0xC0, 0xE0, 0xF0, 0xF0, 0xF8, 0x78, 0x18, 0x08,
0x08, 0x18, 0x38, 0xF8, 0xF8, 0xF0, 0xF0, 0xE0, 0xE0, 0xC0, 0x80, 0x01, 0x01, 0x03, 0x07, 0x0F,
0x3F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFC, 0xF0, 0xE0, 0xF0, 0xF0, 0xF8, 0xE0, 0x80, 0x00,
0x00, 0x00, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x07, 0x01,
0x00, 0x00, 0x00, 0x00, 0xF8, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x7F, 0xFF, 0xFF, 0xFC, 0xF0, 0x00, 0x00,
0x00, 0x00, 0x03, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x0F, 0x0F, 0x07, 0x07, 0x00,
0x00, 0x00, 0x0F, 0x0F, 0x0F, 0x07, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xE0, 0x80,
0x00, 0x00, 0x00, 0x02, 0x1F, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xF8, 0xF8,
0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFF, 0xFF, 0x3F, 0x0F, 0x00, 0x00,
0x00, 0x00, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF0, 0xF0, 0xF0, 0xF0, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xF0, 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFE, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x01, 0x03, 0x03, 0x07, 0x0F, 0x0F, 0x1F, 0x1F, 0x1F, 0x1F,
0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x0F, 0x0F, 0x07, 0x03, 0x01, 0x80, 0x80, 0xC0, 0xE0, 0xF0,
0xFC, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0x1F, 0x07, 0x07, 0x07, 0x0F, 0x0F, 0x07, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x07, 0x0F, 0x07, 0x03, 0x01, 0x03, 0x07, 0x0F,
0x1F, 0x1F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFC, 0xFC, 0xFC, 0xF8, 0xF8, 0xF8,
0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xFC, 0xFC, 0xFC, 0xFE, 0xFE, 0xFF, 0xFF, 0x7F, 0x7F, 0x3F, 0x3F,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7C, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x02, 0x07, 0x07, 0x0F, 0x0F, 0x1F, 0x1F, 0x1F, 0x07, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03,
0x03, 0x7F, 0x7F, 0x7F, 0x7F, 0x3F, 0x3F, 0x3F, 0x39, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
static const byte LOGO_WIDTH = 64;
static const byte LOGO_HEIGHT = 64;

void setup() {

//START A SERIAL SESSION

Serial.begin(9600);

//INITIALIZE THE LCD

lcd.begin(LCD_WIDTH, LCD_HEIGHT);
lcd.clear();

//INITIALIZE THE ARDUINO PINS FOR INPUT/OUTPUT

pinMode(btnPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(pwm, OUTPUT);

//TURN ON THE LCD AND INSERT TEXT AND LOGO

digitalWrite(ledPin, HIGH);
lcd.setCursor(10,0);
lcd.print("TINKERWATCH");
lcd.setCursor(10,1);
lcd.drawBitmap(tinkerwatch, LOGO_WIDTH, LOGO_HEIGHT);
 //DELAY FOR 5 SECONDS AND THEN CLEAR THE LCD AND TURN BACKLIGHT OFF
delay(5000);
lcd.clear();
digitalWrite(ledPin, LOW);
}

void loop() {

//CHECK THE SERIAL PORT FOR INCOMING MESSAGES

//THE ARDUINO APP SENDS A TEXT STRING THROUGH BLUETOOTH EVERY SECOND
//THE STRING SHOULD RESEMBLE THIS: date | time | phone | text \n
while(Serial.available() > 0){

//READ THE STRING TO THE FIRST "|" DIVIDER AND STORE AS A VARIABLE
String myDate = Serial.readStringUntil('|');
Serial.read();
//STORE THE NEXT SECTION OF STRING AS A VARIABLE
String myTime = Serial.readStringUntil('|');
Serial.read();
//STORE THE THIRD SECTION OF STRING AS A VARIABLE
String myPhone = Serial.readStringUntil('|');
Serial.read();
//STORE THE FINAL SECTION AS A VARIABLE
String myText = Serial.readStringUntil('\n');
//CHECK TO SEE WHAT IS STORED IN THE TIME VARIABLE
//AND DISPLAY IT TO THE SCREEN
if(myTime.indexOf('time') >= 0){
lcd.setCursor(0,3);
lcd.print("Comm Error");
}else{
lcd.setCursor(0,3);
lcd.print(" " + myTime);
}

//CHECK TO SEE WHAT IS STORED IN THE DATE VARIABLE

//AND DISPLAY IT TO THE SCREEN
if(myDate.indexOf('date') >= 0){
lcd.setCursor(0,2);
lcd.clearLine();
}else{
lcd.setCursor(0,2);
lcd.print(myDate);
}

//CHECK THE PHONE VARIABLE TO SEE IF A CALL IS

//BEING RECIEVED. IF SO, TURN ON THE BACKLIGHT
//AND VIBRATE THE MOTOR
if(myPhone.indexOf('phone') >= 0){
lcd.setCursor(0,6);
lcd.clearLine();
lcd.setCursor(0,7);
lcd.clearLine();
digitalWrite(pwm, LOW);
// digitalWrite(ledPin, LOW);
}else{
digitalWrite(ledPin, HIGH);
lcd.setCursor(0,6);
lcd.drawBitmap(ph_15, PHONE_WIDTH, PHONE_HEIGHT);
lcd.setCursor(PHONE_WIDTH + 1,6);
lcd.print(myPhone);
//Turn LCD On
lcdCount = 10;
//Motor Vibration Pattern
digitalWrite(pwm, HIGH);
delay(500);
digitalWrite(pwm, LOW);
delay(500);

//CHECK THE PHONE VARIABLE TO SEE IF A CALL IS

//BEING RECIEVED. IF SO, TURN ON THE BACKLIGHT
//AND VIBRATE THE MOTOR
if(myText.indexOf('text') >= 0){
lcd.setCursor(0,6);
lcd.clearLine();
lcd.setCursor(0,7);
lcd.clearLine();
digitalWrite(pwm, LOW);
// digitalWrite(ledPin, LOW);
 }else{
digitalWrite(ledPin, HIGH);
lcd.setCursor(0,6);
lcd.drawBitmap(txt_ico, TEXT_WIDTH, TEXT_HEIGHT);
lcd.setCursor(PHONE_WIDTH + 1,6);
lcd.print("Text From:");
lcd.setCursor(PHONE_WIDTH + 1,7);
lcd.print(myText);
//Turn LCD On
lcdCount = 10;
//Motor Vibration Pattern
digitalWrite(pwm, HIGH);
delay(250);
digitalWrite(pwm, LOW);
delay(250);
digitalWrite(pwm, HIGH);
delay(250);
digitalWrite(pwm, LOW);
delay(250);
}
}

//DETECT WHEN THE BUTTON HAS BEEN PRESSED

//AND TURN ON THE BACKLIGHT
buttonState = digitalRead(btnPin);
if (buttonState == LOW) {
held++;
} else {
held=0;
}
if(held > 10 && held < 100 && restart == 0){
restart++;
held=0;
}else if(held > 500 && restart > 0){
restart=0;
held=0;
//softReset();
lcdCount = 0;
}

//BACKLIGHT LOOP
 if(lcdCount < 15 ){
digitalWrite(ledPin, HIGH);
lcdCount += 1;
}
if(lcdCount >= 15){
digitalWrite(ledPin, LOW);
lcdCount = 20;
}

Step 8: The Android Code

With the Arduino code completed, we can now turn our efforts to creating a quick Android App
that will allow us to communicate with it. For quick app mach-ups, I like to turn to MITs App
Inventor. If you want a quick run through on how to create apps with it, you can watch my Make
An Android App In 7 Minutes tutorial. The app I made was very simple that essentially had a
connect/disconnect button for the bluetooth and then it would send the date/time and
phone/text notifications through it. Since I cant really export working files from AppInventor,
well have to settle for images of the layout I created. If you dont want to create your own code,
you can download mine at the Google Play app store. ITS IMPORTANT TO NOTE THAT THE
BLUETOOTH DEVICE MUST BE PAIRED WITH THE ARDUINO IN THE SETTINGS BEFORE YOU CAN
USE IT IN THE APP.

Step 9: Testing the Functionality

Now that all of the coding is done, we can upload the code to our Arduino and test it out. After you
see the splash screen, it will then wait for input from your phone before displaying time. As said in
bold above, make sure that the bluetooth device is paired with your Android device in the settings
first. Then you can launch your app and connect to it. If everything is successful, you should see
the date and time on the screen. Pushing the button should activate the backlight. And last but not
least, whenever you receive a call or a text, the screen should light up and the motor should buzz.

Step 10: Shrinking It All Down

Now that we have the software and hardware to make a functioning smartwatch, we now need to
make it look like a smartwatch. The first step is to take the mess of wires connected to the
breadboard and solder them all together into a simple little circuit board. If you have the ability to
design and fabricate your own circuit board, then that would be the best route. Since I dont
currently have the ability to do that, I just used a little perfboard that I cut to the size of the LCD
screen and began soldering all the components to that.

I had the Arduino micro, the bluetooth module, the motor, and the LCD screen soldered to once
side of the perfboard and the resistors and connecting wires soldered to the back (with the
backlight button wired off to the side). I ended up adding a diode to the motor for protections, and
a 10k Ohm resistor to the momentary button. Another tip for the motor is to make sure that the
head of the motor isnt being obstructed by anything. Otherwise, the vibrating top of the motor
might get stuck. How you arrange everything is completely up to you, your skill level, and what you
have to work with.

Step 11: Powering It Up

Ok. Time for the key component that makes this project tic (pun intended). The watch obviously
needs a source of power. Ideally, it should be a rechargeable battery that can be recharged using
any micro-usb cable (just like most portable devices). To achieve this, I got a 3.7v 100 mAh Li-ion
battery and a 1 amp micro-usb charging board that acts as a surge protector and regulator. After
the project, I found this battery that would probably make a better option.

I soldered the battery to the charging board. Theres a + and output from the charging board
that goes to the Arduino. I soldered some wires to it, but didnt connect them to the Arduino yet.
On the positive wire, I soldered a mini switch so that the watch can be turned on and off. Then I
hot glue everything to the back of the perfboard (on the resistor side), but I still didnt solder it
the Arduino yet.

Before soldering the charging board to the Arduino, I tweaked the code and made sure
everything was perfect and then re-uploaded it one last time to the Arduino. I say last time
because it will be difficult to upload anything to it after its all been shoved inside of the
smartwatch case. With the code uploaded, you can now solder the charging board wires to the
VCC and GND pins or the RAW and GND pins on the Arduino and then test it out!

Step 12: Making the Case / Finishing Up

We have made it to the final step! This is the fun part where we take our smartwatch monstrosity
and make it look purdy. What I did was take the measurements for the watch, the screen, the
backlight button, the on/off switch, and the micro-USB charger and inputed them into a CAD
program. For simplicities sake, I used Tinkercad, and online CAD program. The watch size ended up
being about 1 3/4 inches wide and tall, which is tolerable. But it also ended up being 1 thick,
which is not as desirable. Most of that space was being used up by the battery I chose. So, in
retrospect, Ill probably end up going with a thinner, but wider battery.
I took the CAD model and printed it out using a 3D printer. It took a couple of tries before I was
able to get everything to fit. To finish things off, I added the screen protector that I salvaged from
the original cell phone, and a watch band. Overall, Im happy with the results. If I were to revisit
this project, Id probably opt for a slimmer battery, smaller bluetooth, and a fabricated PCB.
Hopefully this inspires some of you to upcycle your own old cell phones into something cool!