I Turned an Indian Truck Into a Crazy Alarm Clock

by rohanbarnwal in Circuits > Arduino

27 Views, 0 Favorites, 0 Comments

I Turned an Indian Truck Into a Crazy Alarm Clock

ChatGPT Image Apr 22, 2026, 10_03_41 PM.png

It all started with a random Instagram reel.

I came across one of those fancy Dodge Challenger alarm clocks that start with aggressive engine sounds instead of a normal alarm tone. Honestly, it looked super cool — but after watching it for a while, I thought:

"Why does this only exist as a sports car? Why not make something that feels more colorful, loud, and uniquely Indian?"

And that’s where the idea for this project was born.

Instead of building another sleek car-themed clock, I decided to create an Indian truck-inspired alarm clock — something that feels straight out of Indian highways with bright lights, loud horns, diesel engine sounds, and all the over-the-top personality that Indian trucks are famous for.

The entire body was designed for 3D printing and manufactured using JUSTWAY, which made it surprisingly easy to turn the idea into a real physical object. If you're planning to build detailed enclosure-based electronics projects, they’re definitely worth checking out.

The final result turned out way more immersive than I expected.

Every morning, instead of a boring beep:

  1. The truck “starts”
  2. Engine ignition audio plays
  3. LEDs begin flashing
  4. Truck horn and idle sounds loop continuously
  5. The clock behaves like a miniature diesel truck sitting on your desk

And after five minutes, the truck powers down with a realistic engine-off sound.

It’s weird.

It’s loud.

It’s unnecessary.

And honestly, that’s exactly what makes it fun.

The Story Behind the Build

Indian trucks have a completely different vibe compared to sports cars.

They’re colorful, loud, dramatic, and somehow full of character. From painted bumpers to decorative lights and massive horns, they already feel mechanical and animated. So instead of copying the original Dodge-style concept directly, I redesigned the idea around a truck platform.

The goal was not just to display time.

I wanted the clock to feel alive.

That’s why I added:

  1. Engine startup sounds
  2. Idle loops
  3. Truck horn audio
  4. Flashing LEDs
  5. Automatic shutdown sequence

The result feels more like a tiny truck simulator than an alarm clock.

Features

Main Features

  1. Dual OLED displays for hours and minutes
  2. Real-time clock using DS3231 RTC
  3. Realistic truck startup audio
  4. Continuous engine idle + horn sequence
  5. Automatic engine shutdown after 5 minutes
  6. Blinking LEDs synchronized with alarm state
  7. Fully Arduino controlled
  8. Custom 3D printed truck enclosure


Supplies

download (10) - Copy.png

Arduino Mega: Main Controller

DS3231 RTC Module: Real-time clock

DFPlayer Mini: Audio playback

2x OLED Displays: Time display

4x LEDs: Truck lighting effects

Speaker: Audio output

3D Printed Body: Truck enclosure

Jumper Wires: Connections

Power Supply: System power

3D Printed Parts

The truck body was custom designed and then 3D printed using JUSTWAY.

The reason I chose professional printing instead of printing locally was because:

  1. Better surface finish
  2. Cleaner detailing
  3. More accurate fitment
  4. Less post-processing

Since the enclosure has multiple sections for displays, LEDs, and speaker mounting, dimensional accuracy mattered a lot.


Working Principle

The system uses the DS3231 RTC module to continuously track the current time.

When the preset alarm time is reached:

  1. The DFPlayer Mini plays a truck startup sound
  2. LEDs begin blinking
  3. Engine idle and horn sounds loop continuously
  4. The alarm runs for 5 minutes
  5. A truck shutdown sound plays
  6. Everything turns off automatically

Meanwhile, the OLED displays continuously show:

  1. Left OLED → Hours
  2. Right OLED → Minutes

This split-display design makes the clock look much more futuristic and dashboard-like.

Circuit Explanation

UJJK.png

The Arduino UNO controls all modules:

  1. RTC provides accurate time
  2. DFPlayer handles audio playback
  3. OLEDs display the time
  4. LEDs simulate truck lights

The BUSY pin from the DFPlayer is used to detect when an audio track finishes playing. This allows the Arduino to automatically start the next sound file without delays or manual timing.

That small detail made the startup and looping sequence feel much smoother.

Design Process

The enclosure design took multiple iterations.

At first, I tried making the truck shape too realistic, but it became difficult to fit:

  1. OLED displays
  2. Speaker
  3. Wiring
  4. Arduino board

So I simplified the structure while keeping the recognizable Indian truck styling.

The OLED displays were separated intentionally so the clock resembles a vehicle dashboard.

Another challenge was speaker placement because enclosed audio can sound muffled inside 3D printed bodies. I had to experiment with vent placement to improve sound clarity.

Audio Sequence Logic

The audio system works in stages.

Startup Phase

The truck ignition sound plays first.

df.play(1);

Looping Phase

After startup completes, the code continuously cycles through:

  1. Engine idle
  2. Horn sounds
int loopTracks[] = {2, 4, 4};

The BUSY pin is monitored to detect track completion.

Shutdown Phase

After five minutes:

df.play(3);

The truck shutdown sound plays and the LEDs turn off.

OLED Display Logic

Two separate OLED displays are used:

  1. One for hours
  2. One for minutes

This gives the project a more mechanical dashboard-style appearance instead of looking like a normal digital clock.

sprintf(hourStr, "%02d", h);
sprintf(minStr, "%02d", m);

Challenges Faced

Audio Synchronization

One of the biggest issues was making audio transitions feel natural.

Simple delay-based timing felt unreliable because audio track lengths varied slightly. Using the DFPlayer BUSY pin solved this problem cleanly.

OLED Wiring

Running two OLED displays simultaneously required careful handling of software I2C pins.

Internal Space

Fitting:

  1. Speaker
  2. Arduino
  3. Wiring
  4. DFPlayer
  5. LEDs

inside the truck body was honestly harder than writing the code.


Code

#include <Wire.h>
#include <U8g2lib.h>
#include "RTClib.h"
#include "DFRobotDFPlayerMini.h"

// 🟢 OLED1 → SCL=22, SDA=24
U8G2_SSD1306_128X64_NONAME_F_SW_I2C oled1(U8G2_R0, 22, 24, U8X8_PIN_NONE);

// 🔵 OLED2 → SCL=23, SDA=25
U8G2_SSD1306_128X64_NONAME_F_SW_I2C oled2(U8G2_R0, 23, 25, U8X8_PIN_NONE);

// RTC
RTC_DS3231 rtc;

// DFPlayer
DFRobotDFPlayerMini df;

// BUSY pin
const int busyPin = 43;
bool lastBusy = HIGH;

// LEDs
int ledPins[] = {34, 36, 38, 40};
bool ledState = false;

// States
int state = 0;
// 0 = idle
// 1 = playing 0001
// 2 = looping
// 3 = stopped

bool startTriggered = false;
bool stopTriggered = false;

// Loop pattern
int loopTracks[] = {2, 4, 4};
int loopIndex = 0;

void setup() {
Serial.begin(115200);
Serial1.begin(9600);
Wire.begin();

oled1.begin();
oled2.begin();

oled1.setBusClock(50000);
oled2.setBusClock(50000);

pinMode(busyPin, INPUT);

for (int i = 0; i < 4; i++) {
pinMode(ledPins[i], OUTPUT);
}

if (!rtc.begin()) {
Serial.println("RTC NOT FOUND");
while (1);
}

if (!df.begin(Serial1)) {
Serial.println("DFPlayer NOT FOUND");
while (1);
}

df.volume(30);
}

void loop() {

DateTime now = rtc.now();
int h = now.hour();
int m = now.minute();

// ---------- OLED ----------
char hourStr[3], minStr[3];
sprintf(hourStr, "%02d", h);
sprintf(minStr, "%02d", m);

oled1.clearBuffer();
oled1.setFont(u8g2_font_logisoso32_tr);
oled1.drawStr((128 - oled1.getStrWidth(hourStr)) / 2, 45, hourStr);
oled1.sendBuffer();

oled2.clearBuffer();
oled2.setFont(u8g2_font_logisoso32_tr);
oled2.drawStr((128 - oled2.getStrWidth(minStr)) / 2, 45, minStr);
oled2.sendBuffer();

// ---------- START @ 12:50 ----------
if (h == 12 && m == 50 && !startTriggered) {
Serial.println("START SEQUENCE");

df.play(1); // 0001
state = 1;
startTriggered = true;
loopIndex = 0;
}

// ---------- STOP @ 12:55 ----------
if (h == 12 && m == 55 && !stopTriggered) {
Serial.println("STOP SEQUENCE");

df.stop();
delay(200);
df.play(3); // 0003

state = 3;
stopTriggered = true;
}

// reset trigger
if (!(h == 12 && m == 50)) startTriggered = false;
if (!(h == 12 && m == 55)) stopTriggered = false;

// ---------- DFPLAYER ----------
bool currentBusy = digitalRead(busyPin);

if (lastBusy == LOW && currentBusy == HIGH) {

if (state == 1) {
state = 2;
df.play(loopTracks[loopIndex]);
}

else if (state == 2) {
loopIndex = (loopIndex + 1) % 3;

df.play(loopTracks[loopIndex]);

Serial.print("Loop: ");
Serial.println(loopTracks[loopIndex]);
}
}

lastBusy = currentBusy;

// ---------- LED BLINK ----------
if (state == 2) {
ledState = !ledState;

for (int i = 0; i < 4; i++) {
digitalWrite(ledPins[i], ledState);
}
} else {
for (int i = 0; i < 4; i++) {
digitalWrite(ledPins[i], LOW);
}
}

delay(200);
}

Testing Process

I Built a Desi Truck Alarm Using Arduino 🤯 #viral #shorts #shortsfeed #arduino #diyelectronics


Testing this project was hilarious.

Every time the alarm triggered, the desk suddenly sounded like a truck depot.

The first successful test where:

  1. LEDs blinked correctly
  2. Startup sound played
  3. Horn loop worked
  4. Shutdown happened automatically

felt incredibly satisfying.


Final Results

The final build turned out exactly how I imagined:

  1. Loud
  2. Colorful
  3. Slightly ridiculous
  4. But extremely fun

It doesn’t just tell time anymore.

It has personality.

Future Improvements

Here are a few upgrades I may add later:

  1. Adjustable alarm time using buttons
  2. Bluetooth speaker mode
  3. RGB lighting
  4. ESP32-based WiFi synchronization
  5. Better amplifier for louder sound
  6. Animated OLED graphics
  7. Touch controls

Conclusion

This project started as a random Instagram inspiration and slowly turned into one of the most entertaining desk gadgets I’ve ever built.

I really liked the idea of mixing:

  1. electronics
  2. sound design
  3. 3D printing
  4. automotive aesthetics

into a single project.

And honestly, turning an everyday alarm clock into a tiny Indian truck with startup sounds made waking up way more fun.