How to Make a Simple Smart Watch

How to Make a Simple Smart Watch

by

This guide walks you through how to make a simple smart watch using affordable components like an Arduino, OLED display, and sensors. You’ll learn to assemble, code, and customize your wearable device—no prior experience needed.

Key Takeaways

  • Choose the right microcontroller: An Arduino-compatible board like the ESP32 is ideal for beginners due to its built-in Wi-Fi and Bluetooth.
  • Use an OLED display: A small 0.96-inch OLED screen provides clear visuals and low power consumption for your smart watch.
  • Solder carefully: Proper soldering ensures reliable connections between components—practice on scrap wires first if you’re new.
  • Write efficient code: Use Arduino IDE to program time, notifications, and sensor data; keep code modular for easy updates.
  • Design a compact case: 3D printing or repurposing a plastic box helps protect electronics and gives your watch a professional look.
  • Power with a rechargeable battery: A 3.7V lithium-ion battery with a charging module keeps your watch running for hours.
  • Test incrementally: Power up and test each component before final assembly to catch errors early.

Introduction: Build Your Own Smart Watch from Scratch

Have you ever wanted to wear a device that tells time, tracks your steps, and connects to your phone—all built by you? Now you can. This guide will show you how to make a simple smart watch using beginner-friendly electronics, open-source software, and a bit of creativity. Whether you’re a student, hobbyist, or tech enthusiast, building your own smart watch is a fun and educational project that teaches core skills in electronics, coding, and design.

You don’t need to be an engineer to succeed. With the right parts, clear instructions, and patience, anyone can assemble a functional wearable device. This project uses widely available components, costs under $50, and can be completed in a weekend. By the end, you’ll have a custom smart watch that displays time, date, step count, and even receives notifications from your smartphone.

We’ll cover everything from selecting parts to writing code and assembling the final product. Along the way, you’ll learn about microcontrollers, sensors, power management, and basic programming. Plus, we’ll share tips to troubleshoot common issues and customize your watch further. Let’s get started!

What You’ll Need: Tools and Components

How to Make a Simple Smart Watch

Visual guide about How to Make a Simple Smart Watch

Image source: mir-s3-cdn-cf.behance.net

Before diving into assembly, gather all the necessary tools and parts. Having everything ready will save time and reduce frustration.

Essential Components

  • Microcontroller: ESP32 DevKit (recommended for Wi-Fi/Bluetooth support)
  • Display: 0.96-inch OLED I2C screen (128×64 pixels)
  • Battery: 3.7V 500mAh lithium-ion rechargeable battery
  • Charging module: TP4056 lithium battery charger with protection
  • Step counter: MPU6050 accelerometer/gyroscope sensor
  • Push buttons: 2–3 tactile switches for navigation
  • Strap: Adjustable watch band (silicone or fabric)
  • Enclosure: 3D-printed case or small plastic box
  • Wires: Jumper wires (male-to-female and male-to-male)
  • Breadboard (optional): For testing before soldering

Tools Required

  • Soldering iron and solder
  • Wire strippers
  • Multimeter (for testing connections)
  • Hot glue gun or epoxy (for securing parts)
  • Small screwdrivers
  • Computer with USB cable (for programming)

Software Needed

  • Arduino IDE (free download from arduino.cc)
  • ESP32 board support package (install via Boards Manager)
  • Libraries: Adafruit SSD1306, Adafruit GFX, Wire, WiFi, Bluetooth

Most of these parts are available on Amazon, Adafruit, SparkFun, or AliExpress. Total cost typically ranges from $35 to $50, depending on quality and shipping.

Step 1: Setting Up the Microcontroller

The ESP32 is the brain of your smart watch. It handles time, sensors, display, and wireless communication. Let’s get it ready.

Install Arduino IDE and ESP32 Support

First, download and install the Arduino IDE on your computer. Then, add support for the ESP32:

  1. Open Arduino IDE → File → Preferences.
  2. In “Additional Boards Manager URLs,” paste: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  3. Go to Tools → Board → Boards Manager.
  4. Search for “ESP32” and install the “esp32 by Espressif Systems” package.
  5. Select your board: Tools → Board → ESP32 Dev Module.

Test the ESP32

Connect your ESP32 to your computer via USB. Open the Blink example (File → Examples → 01.Basics → Blink). Upload it. If the onboard LED blinks, your board is working.

Install Required Libraries

Go to Sketch → Include Library → Manage Libraries. Search and install:

  • Adafruit SSD1306
  • Adafruit GFX Library
  • Wire (usually pre-installed)
  • WiFi and Bluetooth (built into ESP32 core)

These libraries allow the ESP32 to control the OLED screen and communicate wirelessly.

Step 2: Connecting the OLED Display

The OLED screen shows time, steps, and menus. It’s small, bright, and energy-efficient.

Wiring the OLED to ESP32

The OLED uses I2C communication, so only four wires are needed:

  • OLED VCC → ESP32 3.3V
  • OLED GND → ESP32 GND
  • OLED SCL → ESP32 GPIO 22
  • OLED SDA → ESP32 GPIO 21

Use male-to-female jumper wires for testing on a breadboard. Double-check connections—reversed power can damage the screen.

Test the Display

Upload this test code to display “Hello, World!”:

#include 
#include 
#include 

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("Hello, World!");
  display.display();
}

void loop() {}

If text appears, your display is working. If not, check I2C address (try 0x3D) and wiring.

Step 3: Adding the Step Counter (MPU6050)

The MPU6050 sensor detects motion and counts steps. It’s cheap and accurate for basic tracking.

Wiring the MPU6050

Connect the sensor to the ESP32:

  • VCC → 3.3V
  • GND → GND
  • SCL → GPIO 22
  • SDA → GPIO 21

Note: The MPU6050 shares the I2C bus with the OLED, so no extra pins are needed.

Calibrate and Read Sensor Data

Use the Wire library to read accelerometer values. Here’s a simple sketch to print X, Y, Z acceleration:

#include 

const int MPU_ADDR = 0x68;
int16_t accX, accY, accZ;

void setup() {
  Serial.begin(115200);
  Wire.begin();
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x6B);
  Wire.write(0);
  Wire.endTransmission(true);
}

void loop() {
  Wire.beginTransmission(MPU_ADDR);
  Wire.write(0x3B);
  Wire.endTransmission(false);
  Wire.requestFrom(MPU_ADDR, 6, true);

  accX = Wire.read() << 8 | Wire.read();
  accY = Wire.read() << 8 | Wire.read();
  accZ = Wire.read() << 8 | Wire.read();

  Serial.print("X: "); Serial.print(accX);
  Serial.print(" Y: "); Serial.print(accY);
  Serial.print(" Z: "); Serial.println(accZ);

  delay(500);
}

Open the Serial Monitor (Tools → Serial Monitor) to see values. Move the board to confirm it responds.

Implement Step Counting

Step detection uses changes in acceleration. A simple algorithm:

  • Calculate total acceleration: accTotal = sqrt(accX² + accY² + accZ²)
  • Detect peaks above a threshold (e.g., 12000)
  • Count steps when peaks occur with timing gaps

Store step count in a variable and reset daily. Display it on the OLED.

Step 4: Powering Your Smart Watch

A reliable power system is crucial. Your watch needs long battery life and safe charging.

Choosing the Right Battery

A 3.7V lithium-ion battery (e.g., 500mAh) provides enough power for 8–12 hours. Avoid larger batteries—they add bulk.

Adding a Charging Module

The TP4056 module charges the battery via USB and protects against overcharge/discharge. Wire it like this:

  • Battery + → B+ on TP4056
  • Battery – → B– on TP4056
  • USB + → IN+ on TP4056
  • USB – → IN– on TP4056
  • OUT+ → ESP32 VIN
  • OUT– → ESP32 GND

The TP4056 outputs 5V, but the ESP32 needs 3.3V. Use a 3.3V regulator (like AMS1117) between OUT+ and VIN, or power directly from 3.3V pin if current is low.

Power Management Tips

  • Turn off Wi-Fi/Bluetooth when not in use to save power.
  • Put the ESP32 into deep sleep mode when idle.
  • Use a low-power OLED library if available.

Test battery life by running the watch continuously. Aim for at least 6 hours.

Step 5: Programming the Watch Functions

Now, let’s bring it all together with code. Your smart watch will show time, steps, and menus.

Displaying Time and Date

Use the ESP32’s internal RTC (Real-Time Clock) or sync time via Wi-Fi. For Wi-Fi time:

  • Connect to your home network.
  • Use NTP (Network Time Protocol) to get current time.
  • Update every hour to save power.

Example: Use the WiFi.h and time.h libraries to fetch time from pool.ntp.org.

Creating a Menu System

Use push buttons to navigate:

  • Button 1: Switch screens (time → steps → settings)
  • Button 2: Confirm or reset steps

Store the current screen in a variable (e.g., int screen = 0;). Update display based on value.

Adding Notifications (Optional)

With Bluetooth, your watch can receive alerts from your phone. Use the ESP32’s BLE (Bluetooth Low Energy) to connect to an app like “BLE Monitor” on Android. Display “New Message” when a notification arrives.

Full Code Example

Combine all features into one sketch. Start with time and steps, then add menus and sensors. Keep functions separate for clarity:

void showTime() {
  // Get and display current time
}

void showSteps() {
  // Read sensor and display step count
}

void checkButtons() {
  // Read button states and change screen
}

Upload and test each function before final assembly.

Step 6: Assembling the Watch

Now it’s time to put everything together into a wearable form.

Soldering the Circuit

Remove components from the breadboard and solder them onto a protoboard or custom PCB. Tips:

  • Use short wires to reduce noise.
  • Solder in this order: power, display, sensor, buttons.
  • Double-check polarity—reversed power can fry components.

Secure wires with hot glue to prevent breaks.

Building the Case

You have two options:

  • 3D Print: Design a case in Tinkercad or download a template. Print in PLA or PETG.
  • Repurpose: Use a small plastic box (e.g., pill container). Drill holes for buttons and USB port.

Ensure the screen is visible and buttons are accessible. Leave space for the battery.

Attaching the Strap

Glue or screw the case to a watch band. Use strong adhesive like epoxy or drill holes for rivets. Make sure it’s comfortable and secure.

Step 7: Testing and Troubleshooting

Before wearing your watch, test it thoroughly.

Common Issues and Fixes

  • Screen not working: Check I2C address, wiring, and contrast settings.
  • No step count: Recalibrate MPU6050 threshold. Ensure sensor is flat.
  • Battery drains fast: Disable Wi-Fi, reduce screen brightness, use deep sleep.
  • Buttons unresponsive: Check solder joints and pull-up resistors.
  • ESP32 won’t upload: Hold BOOT button during upload, check COM port.

Use a multimeter to test continuity and voltage. Re-solder loose connections.

Final Test

  • Charge the battery fully.
  • Power on and verify all functions.
  • Wear it for an hour to check comfort and performance.

Make adjustments as needed.

Customization Ideas

Once your basic watch works, enhance it:

  • Add a heart rate sensor (e.g., MAX30102).
  • Include a temperature sensor.
  • Design a custom watch face with graphics.
  • Sync data to a phone app via Bluetooth.
  • Add vibration motor for alerts.

Share your design online or 3D print cases in different colors.

Conclusion: You Built a Smart Watch!

Congratulations! You’ve successfully learned how to make a simple smart watch from scratch. This project teaches valuable skills in electronics, coding, and design—all while creating a functional wearable device.

You started with basic components, wired them together, wrote code, and assembled a custom case. Along the way, you solved problems, tested systems, and personalized your watch. That’s the joy of DIY tech.

This smart watch may not have all the features of a commercial model, but it’s yours—built with your hands and creativity. Use it as a learning tool, a fashion statement, or a foundation for more advanced projects.

Keep experimenting. Add sensors, improve battery life, or design a PCB. The possibilities are endless. And remember: every expert was once a beginner. You’ve taken the first step.

Now go show off your creation!