Next Time: a Tiny Desk Clock

by Next Builder DIY in Circuits > Clocks

295 Views, 5 Favorites, 0 Comments

Next Time: a Tiny Desk Clock

3D Printed_20250623_222234_0000.jpg

Sometimes, all it takes is a tiny spark to ignite big ideas. That’s exactly what this little cube of inspiration is all about. Meet Next Time, a minimalistic yet meaningful desk clock designed to be your silent motivator. With its compact size, clean look, and a bold display tucked inside a sleek enclosure, it’s more than just a timekeeper — it’s a gentle reminder that there’s always a next time to improve, grow, and build better.

Whether I'm studying or creating a new DIY project, I always keep this tiny clock on my desk. Every time I glance at it, it reminds me to push my limits and do better — to refine my ideas and never stop learning.

An NTP (Network Time Protocol) server is used here to fetch accurate time over Wi-Fi, ensuring the clock is always in sync with real-world time. This adds convenience and eliminates the need for a physical RTC module. The NTP server connects to the internet and retrieves the exact time from time servers globally, making it a reliable time source.

For your own motivation, you can even personalize it with words that resonate with you — like Focus, Hard Work, Next Step, or Create. I’ve also included the original design file, so you can easily edit it and make it truly your own.

🌟 Important Notice: I’ve been building this project over the past two weeks, and just as I reached the final stage, the OLED display cracked and got damaged during assembly. It was disappointing after all the effort, but that’s part of the DIY process. I’ve already ordered a brand new DFRobot 0.96" OLED Display to replace it. Before the damage, everything was tested and worked perfectly — the display showed clear output using the provided code. You can follow all the steps confidently to build your own. Just be careful with the display during handling — and remember, every setback is part of the learning journey.

Supplies

3D Printed_20250623_223505_0000.jpg
  1. 0.96" OLED Display
  2. 3.7v Lipo Battery
  3. DFRobot Bettle ESP32-C3

CAD & 3D Printing

To begin, I designed this tiny desk clock case using Fusion 360. You can view the design directly in your browser and download it to open in Fusion 360 for any modifications or creative additions. Feel free to customize and enhance the design as you like!

For 3D printing, you can directly download the STL files listed below:

  1. 1x Cover.stl
  2. 1x Hausing-1.stl

For the 3D printed parts of this project, I used JLC3DP 3D printing service, which is gaining popularity for its high precision, wide material selection, and affordable pricing. They offer industrial-grade printing technologies like SLA, SLS, MJF, and FDM, delivering smooth, accurate, and durable parts suitable for both prototypes and final products. One of the best things about JLC3DP is their fast turnaround time and reliable global shipping, making it easy to get quality parts quickly. Whether you're a hobbyist or a professional, their platform is super convenient. Overall, JLC3DP offers a reliable and budget-friendly solution for anyone working on 3D printed projects. Use this link to get a huge discount on your order.

Downloads

Cover.stl
Hausing-1.stl

Display Assembly

3D Printed_20250623_222842_0000.jpg
3D Printed_20250623_221921_0000.jpg
3D Printed_20250623_222234_0000.jpg

Let’s start by assembling the display. First, I soldered four color-coded wires to the 0.96" OLED display to make the connections simple and organized:

  1. 🔴 Red – VCC (Power)
  2. ⚫ Black – GND (Ground)
  3. 🟢 Green – SCK (Clock)
  4. 🟡 Yellow – SDA (Data)

Once the wires were securely soldered, I fixed the display inside the enclosure. I initially used a hot glue gun, but I don’t recommend it for long-term use — it can get messy and may not hold well over time. Instead, I suggest using B-7000 glue for a cleaner and stronger bond.

Battery Connection

3D Printed_20250623_222719_0000.jpg
3D Printed_20250623_222548_0000.jpg
3D Printed_20250623_221607_0000.jpg

Since DFRobot Beetle ESP32-C3 microcontroller includes an integrated battery charging circuit, there's no need for an external charging module.

To set up the battery, I used the GPIO expander board that comes bundled with the Beetle ESP32-C6. It makes accessing the battery connection points much easier. I soldered the battery’s negative wire to the B– (Battery Negative) pad and the positive wire to the B+ (Battery Positive) pad.

I'm using a 3.7V Lipo battery for this project. Make sure to double-check the polarity before soldering, as reversing the connections could damage the board.

Display Connection

3D Printed_20250623_221237_0000.jpg

Connecting the display to the microcontroller is super simple. On the GPIO expander board that comes with the Beetle ESP32-C6, you’ll find clearly labeled pads for 3.3V, GND, SCL, and SDA. These are exactly what you need to hook up the OLED display.

  1. Display VCC to 3.3v of GPIO Expander
  2. Display GND to GND of GPIO Expander
  3. Display SCK to SCL of GPIO Expander
  4. Display SDA to SDA of GPIO Expander

That’s it — the wiring is complete and ready to go. Make sure the connections are firm and the wires are not too long to avoid signal interference.

Arduino IDE Setup

Install Arduino IDE

If you do not already have it, download and install Arduino IDE 2.0 latest Version from official website of Arduino.

Add the ESP32-C3 Board Support URL

  1. Open Arduino IDE.
  2. Go to File > Preferences.
  3. In the Additional Board Manager URLs field, paste the following URL:
https://espressif.github.io/arduino-esp32/package_esp32_index.json
  1. Click OK to save your changes.

Install the ESP32 Board.

  1. Go to Tools > Board > Boards Manager.
  2. In the search bar, type ESP32.
  3. Click & Install the latest version of ESP32

Verify Board Installation

  1. Once installed, DFRobot Bettle ESP32-C3 should now appear under Tools > Board.
  2. Select DFRobot Bettle ESP32-C3 from the list to start programming the device.

Uploading Code

Library Installation

Before uploading the code to the microcontroller, it’s important to ensure that all the required libraries are installed in the Arduino IDE. These libraries handle the display and time synchronization features of the clock.

To install them, open the Arduino IDE, go to the Library Manager (Sketch → Include Library → Manage Libraries) then search for each of the following libraries and click Install:

  1. Adafruit GFX
  2. Adafruit SSD1306
  3. NTPClient

Wi-Fi Set-up In Code

Before uploading the code, make sure to update it with your own Wi-Fi credentials. This step is essential, as the clock relies on a Wi-Fi connection to access the NTP server and fetch the current time.

In the code, locate the section that looks like this:

// WiFi credentials
const char *ssid = "YOUR_WIFI_SSID";
const char *password = "YOUR_WIFI_PASSWORD";

Replace "YOUR_WIFI_SSID" with the name of your Wi-Fi network, and "YOUR_WIFI_PASSWORD" with your actual Wi-Fi password. Be sure to keep the quotation marks around your credentials.

Uploading Code

Once everything done, you’re ready to upload the code. Connect the Beetle ESP32-C3 to your computer using a USB-C cable, select the correct board and port from the Tools menu, and hit the Upload button.

#include <WiFi.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

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

// WiFi credentials
const char *ssid = "YOUR_WIFI_SSID";
const char *password = "YOUR_WIFI_PASSWORD";

// NTP settings (India timezone GMT+5:30 = 19800 seconds)
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", 19800, 60000);

// Display variables
unsigned long lastUpdate = 0;
const long updateInterval = 1000;

void setup() {
Serial.begin(115200);

// Initialize OLED with larger fonts
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
Serial.println(F("SSD1306 allocation failed"));
for(;;);
}

display.clearDisplay();
display.setTextColor(SSD1306_WHITE);
display.display();

// Connect to WiFi (hidden from final display)
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) delay(500);

// Initialize NTP client
timeClient.begin();
while(!timeClient.update()) timeClient.forceUpdate();
}

String formatTwoDigits(int number) {
return number < 10 ? "0" + String(number) : String(number);
}

String getFormattedDate(time_t epochTime) {
struct tm *ptm = gmtime((time_t *)&epochTime);
String day = formatTwoDigits(ptm->tm_mday);
String month = formatTwoDigits(ptm->tm_mon + 1);
String year = String(ptm->tm_year + 1900);
return day + "/" + month + "/" + year;
}

String get12HourTime(time_t epochTime) {
struct tm *ptm = gmtime((time_t *)&epochTime);
int hour = ptm->tm_hour;
String period = hour < 12 ? "AM" : "PM";

if (hour == 0) hour = 12; // Midnight
else if (hour > 12) hour -= 12;

return formatTwoDigits(hour) + ":" + formatTwoDigits(ptm->tm_min) + " " + period;
}

void drawCenteredText(String text, int y, int textSize) {
display.setTextSize(textSize);
int16_t x1, y1;
uint16_t w, h;
display.getTextBounds(text, 0, 0, &x1, &y1, &w, &h);
display.setCursor((SCREEN_WIDTH - w) / 2, y);
display.print(text);
}

void loop() {
timeClient.update();

if (millis() - lastUpdate >= updateInterval) {
lastUpdate = millis();
time_t epochTime = timeClient.getEpochTime();

display.clearDisplay();

// DATE SECTION (Top - Yellow)
// Draw a filled rectangle to ensure yellow background
display.fillRect(0, 0, SCREEN_WIDTH, 28, SSD1306_WHITE);
display.setTextColor(SSD1306_BLACK); // Inverted color for better contrast
drawCenteredText(getFormattedDate(epochTime), 10, 2);

// TIME SECTION (Bottom - Blue)
display.setTextColor(SSD1306_WHITE); // Normal color for blue section
String timeStr = get12HourTime(epochTime);

// Draw time (HH:MM)
drawCenteredText(timeStr.substring(0, 5), 38, 3); // Large font for time

// Draw AM/PM indicator
display.setTextSize(2);
display.setCursor((SCREEN_WIDTH/2) + 40, 42); // Right of time
display.print(timeStr.substring(6)); // AM/PM

display.display();
}

// Handle WiFi quietly in background
if (millis() % 10000 == 0 && WiFi.status() != WL_CONNECTED) {
WiFi.reconnect();
}
}

Microcontroller & Battery Assembly

3D Printed_20250623_221747_0000.jpg
3D Printed_20250623_221416_0000.jpg
3D Printed_20250623_220950_0000.jpg

Now it’s time to place the microcontroller and battery into the enclosure. Carefully position the Beetle ESP32-C6 so that its USB Type-C charging port aligns perfectly with the dedicated cutout in the case. This ensures you can easily charge the clock.

Once aligned, place the battery inside the case next to or beneath the board, depending on your internal layout. To secure everything in place, apply a small amount of B-7000 super glue — just enough to hold the components firmly without creating a mess & Let the glue dry completely before moving to the next step.

Final Assembly

With all components securely in place, it’s time to complete the build. Gently close the enclosure using the 3D-printed top cover, making sure everything fits snugly without putting pressure on the wires or display. To finish the assembly neatly, apply a small amount of B-7000 glue along the edges of the cover. This will hold it firmly in place.

Testing

Now it's time to test. Connect with WiFi and the clock will update through NTP server and display the time.

Conclusion

It's a reminder that innovation doesn’t always need to be large in scale — sometimes, the simplest builds leave the deepest impression. It captures the spirit of thinking big while building small — proving that even a palm-sized project can inspire, teach, and motivate.

I hope this little clock encourages others to start small, dream big, and always keep building — because the next big thing might just start with something small sitting on your desk.

Happy Making 🤞🏻