loading

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 I’d 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 weren’t 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 you’re 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.

Here's a list of other parts I used:

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 to…something 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 I’m 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 we’ll 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. It’s about the size of the Arduino pro mini. There are smaller options available, but they require surface mount soldering skills, which I don’t 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. Here’s 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, I’m 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. You’ll 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, you’ll need a black and white image and you’ll need to make sure it’s sized to within the resolution of your screen and saved as a bitmap file format. For my screen it’s 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.

I’ve commented the code to try and explain how it works and what’s 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, you’ll 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 hasn’t 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 MIT’s 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 can’t really export working files from AppInventor, we’ll have to settle for images of the layout I created. If you don’t want to create your own code, you can download mine at the Google Play app store. IT’S 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 don’t 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 isn’t 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 batteryand 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. There’s a + and – output from the charging board that goes to the Arduino. I soldered some wires to it, but didn’t 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 didn’t 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 it’s 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, I’ll 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, I’m happy with the results. If I were to revisit this project, I’d 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!

<p>ohaa s&uuml;per</p>
<p>Great project (!!!!) but are positive and ground switched in your fritzing schematic? The LCD VSS is shown connected to 3V and VDD and VDD1 are connected to GND. I am confused!</p>
<p>WHATS THE ALTERNATE FOR 3D PRINTER TO MAKE WATCH PANNEL?</p>
<p>you can upload the 3D file and order a print from shapeways.com</p>
<p>This is nice ! it opens the door to new ideas</p>
<p>Man I love this, and you gave me a good idea. </p>
<p>Interesting </p>
@Gigafide<br>Nice instructable?I'm definitely going to make one.
@matth68<br>No Fablab in your neighbourhood? Fast and cheap ( most of the time for free) acces to 3D printers and other funny machines in aprox. 5000 makerspaces all around the world. If you can' t Find one and are eager to make this watch you can send me an adressed to yourself big enough enveloppe with enough stamps in it to resend it. Pb for aprox weight etc
<p>Great!! =D</p>
<p>Very nice project, thanks for sharing!</p>
<p>Check out this very easy card shooter (shoots playing cards) build I found : https://www.youtube.com/watch?v=4B_dIVdfJh8</p>
<p>can you post the 3d files</p>
<p>I've been looking for exactly this 'Ble for about a year now. Not so good with designing such circuits and ideas myownself, but I can follow written directions to the letter np. Amazing work, man, truly love it. I'd love to own a &quot;smartwatch&quot; but don't want or need fitness crap or health tracking or yet another cardless payment scam tracking me everywhere and refuse to give a corporation a shaved dime if I can help it. Only thing I gotta figure out now is a case of some kind, don't have access to a 3dprinter at all. So thanks again, this 'Ble is gonna save me about $200 and let me thumb my nose at &quot;them&quot; and their insane 3000% profit margins a little more, man. Might not matter to most, might think I'm crazy but since $$ directly =power anymore and I'm fighting to de-power &quot;the man&quot; in any and every way I can stuff like remaking his &quot;fancy toys&quot; into actually useful-to-me devices that usually cost about 5% of what &quot;the man&quot; is charging for &quot;his&quot; privacy-invading illegal versions made by child slaves overseas using &quot;conflict minerals&quot; and stolen plans is kinda OP-awesome for a modern real man with a functional mind and actual morals like me. </p>
<p>Awesome! but why did you post it after so long?</p>
<p>Contests... :)</p>
<p>Just waiting for the right time ;-)</p>
oh I see....btw I'm also working on a smart watch like yours... I will post an instructable in coming weeks.
<p>I'm totally looking forward to seeing it! Hopefully you can improve upon the mistakes I ran into.</p>
<p>Brilliant! Love it! I name you a time Lord.</p><p>ASh</p>
<p>A Brilliant idea. Thks. for posting it.</p><p>D.Nagh</p>
<p>Brilliant! Thank you so much for posting!</p>
<p>that was impressive, as a mechatronics engineer i would definitely try it!!!</p>
<p>I had a bucket full of scrap electronics ready to be carried to the recycling facility... had to extract the two old cell phone. now i am stuck with them. </p><p>Upcycling is the best!</p>
<p>this a way above my skills as an electronics engineer</p>
Cool!!! Recycled tech, Impressive!!!
I've done the same with a Nokia 5110 a month ago and it works great
which library did you use
<p>This: <a href="http://www.rinkydinkelectronics.com/library.php?id=47" rel="nofollow">http://www.rinkydinkelectronics.com/library.php?id...</a> (a datasheet is on the bottom)</p><p>I don't know how i found it :)<br>It is very usefull, i think it work like your library.</p>
thank you it will be helpful if you give me your code at :- shahidjariwalaz@gmail.com
<p>i try to finish it, all work but it still some imperfections and i need a android application......</p>
You still send your code I can try to make application I will send you if I complete the application and if I find any problem in code I will improve code and send you.
<p>Feel free to use the one I link to in the instructions. It's on the google play store.</p>
<p>Awesome...</p>
<p>its amazing and yes 3 votes!</p>
This is brilliant
<p>Very impressive!</p>

About This Instructable

99,379views

610favorites

License:

More by gigafide:DIY Vintage Streaming Radio With a Raspberry Pi Turn an Old Cell Phone Into a Smartwatch Alexa Ruxpin - Arduino & Raspberry Pi Powered Voice Assistant 
Add instructable to: