How to Build a Bluetooth-Controlled Car
A Bluetooth-controlled car works because the HC-05 module does almost nothing on its own — it's a transparent serial bridge. Pair it with a phone, and any byte the phone app sends over its Bluetooth Serial Port Profile connection lands on the HC-05's UART pins exactly as if someone had typed it into the Arduino's own Serial Monitor. The firmware never has to know Bluetooth exists; it just reads characters like 'F', 'B', 'L', 'R', or 'S' off a serial port the same way it would from a USB cable, and turns each one into a motor command. The actual engineering problem isn't the wireless link at all — it's that the Arduino's logic pins can't drive a DC motor directly, so a separate motor driver has to sit between the two.
What parts does a Bluetooth-controlled car need?
Six roles have to be filled to get from "phone app" to "wheels turning":
- Arduino Uno — runs the firmware, reads incoming Bluetooth data over a serial connection, and decides which way each motor should spin.
- HC-05 Bluetooth module — the wireless link itself. It pairs with a phone over classic Bluetooth SPP and exposes that connection to the Arduino as plain serial data on its RX/TX pins.
- L298N motor driver — a dual H-bridge that takes low-power logic signals from the Arduino and switches the higher current the motors actually need.
- Two DC gear motors — one per side of the chassis, so the car can turn by spinning each side at a different speed or in a different direction.
- 2WD robot chassis — the frame, wheels, and mounting points that hold everything together.
- Battery and wiring — power for the motors and the logic boards, plus jumper wires to connect everything.
How does a phone talk to the Arduino over Bluetooth?
The HC-05 handles pairing and the radio link entirely on its own; from the Arduino's point of view, nothing about the connection looks like Bluetooth. Most Bluetooth RC-car and serial terminal apps send single characters or short strings when a button is pressed — one character for forward, one for stop, and so on — and the HC-05 delivers those bytes straight to the Arduino's RX pin over a standard serial connection, commonly implemented in software with the SoftwareSerial library so the hardware serial port stays free for USB debugging. The firmware's job is just a character check: read a byte, compare it against the expected commands, and set the motor driver's input pins accordingly. There's no pairing code, handshake, or Bluetooth-specific logic anywhere in the sketch itself — that complexity is fully absorbed by the module.
Why does the motor driver need its own battery pack?
The Arduino's 5V regulator and a USB port are both built for logic-level current draw — tens of milliamps — not for spinning motors. A pair of small DC gear motors under load can draw close to a full amp each, and stalling one (say, against a wall) can spike that current further for a moment. Pulling that much current through the Arduino's onboard regulator, or back through a laptop's USB port, risks browning out the board mid-command or damaging the regulator outright. The L298N driver exists specifically to keep that current on its own path: its motor-supply pins take the battery power directly and switch it to the motors, while a separate, much lighter logic connection talks to the Arduino. Motors also generate back-EMF — voltage spikes when their magnetic field collapses as current is switched off — and keeping that on the motor driver's side of the circuit, rather than sharing a rail with the Arduino's logic, is exactly why the two power domains are kept distinct in the first place.
What phone app do you use to control it?
Any generic Bluetooth Serial Terminal or "Bluetooth RC Car" app that lets you pair with an HC-05 and send characters over its SPP connection will work — several are free on both Android app stores, and most let you assign a character to each button (forward, back, left, right, stop) to match whatever the firmware expects. There isn't one specific app this build depends on; the HC-05 side of the protocol is just "receive characters over serial," so the choice of app is entirely up to the builder and what pairing experience they prefer. Whichever app is used, the one thing to confirm before building the firmware is which single character each button actually sends, since that's the exact string the Arduino sketch needs to match.
Watch it built live
We typed this into Compoden's storefront assistant, Soldr, exactly as a customer would:
"I want to build a robot car that I can control from my phone over Bluetooth, using an Arduino Uno"
Soldr assembled a six-part tray on the first pass and explained the build in plain language: "This build lets you create a small robot car that you can steer using your phone. The Arduino Uno R3 CH340G ATmega328P Board will receive commands from your phone and then tell the motors how to move, making the car drive forward, backward, or turn." On the Arduino itself, it was direct about a gap: "It has no built-in wireless features, so you will need to add a separate module for Bluetooth communication (which is not included in this list)." It was equally direct about the motor driver's job: "Motors draw a lot of current, more than the Arduino board can safely provide directly from its pins. This module acts as a bridge, taking low-power signals from the Arduino and using them to control the higher power needed by the motors." Soldr's own coherence check flagged the exact power-budget concern covered above: with a single 9V battery in the tray, it warned that "the total power draw of the active parts in this build is roughly 5050mA. A standard 9V battery... may not be able to provide this much current for very long, leading to the robot stopping unexpectedly."
That flagged gap is real and worth being upfront about: Soldr's parts engine fills roles like "main controller," "motor driver," and "drive motors," but it doesn't currently carry a "Bluetooth module" role for this build path, so it never proposed the HC-05 on its own — it just said so, in its own words, in the paragraph above. Compoden does stock a genuine HC-05 module, and it belongs in this build's cart, so it's included in the parts table below with that context rather than silently added as if Soldr had picked it.
Watch the firmware get generated
We then took the same project to Compoden's VoltIQ code assistant and named every part explicitly, including the module Soldr had flagged as missing:
"I'm building a Bluetooth-controlled robot car with an Arduino Uno, an HC-05 Bluetooth module, an L298N motor driver, and two DC motors. Write the full firmware to read Bluetooth commands (forward/back/left/right/stop) and drive the motors accordingly."
With the module named up front, VoltIQ's own catalog check matched all seven roles cleanly — "Checking the catalog 7/7 matched" — including "Bluetooth Module → HC-05 Bluetooth Module" alongside the microcontroller, motor driver, DC motors, power supply, chassis, and wiring. It described its plan before the code appeared: "The sketch will use SoftwareSerial for the HC-05 module on pins 2 (RX) and 3 (TX), and control the L298N motor driver on pins 4, 5, 6, and 7." The generated sketch opens with #include <SoftwareSerial.h>, then defines BLUETOOTH_RX_PIN 2 and BLUETOOTH_TX_PIN 3 with a comment block spelling out the wiring directly above them — "Arduino D2 (RX) to HC-05 TX" and "Arduino D3 (TX) to HC-05 RX" — before moving into the L298N's IN1–IN4 pin definitions on pins 4 through 7. The build instructions were explicit about the one manual step before it compiles: "Upload this sketch to your Arduino Uno. Install via Library Manager: SoftwareSerial."
Get everything in this build
These are the parts from Soldr's tray, plus the HC-05 Bluetooth module — confirmed in Compoden's live catalog and the same part VoltIQ's firmware above was written against — with live prices and direct add-to-cart links.
| Part | Price | Add to cart |
|---|---|---|
| Arduino Uno R3 CH340G ATmega328P Board | Rs.230 | Add to cart |
| HC-05 Bluetooth Module (SPP, 2.4GHz, Master/Slave) | Rs.240 | Add to cart |
| L298N Motor Driver Module | Rs.180 | Add to cart |
| N20 Micro Metal Gear DC Motor 50RPM 3V (x2) | Rs.91 | Add to cart |
| 2WD Robot Chassis Kit | Rs.280 | Add to cart |
| 9V Battery Snap Connector | Rs.35 | Add to cart |
| Male-to-Male Breadboard Jumper Wires (20cm, 24AWG) | Rs.40 | Add to cart |
| Total | Rs.1187 | Add all 7 to cart |
Soldr's own power-budget warning is worth heeding here rather than skipping: a single 9V battery is enough to get a first test running, but with two motors and an L298N driver pulling roughly 5A combined at peak, a 9V alkaline cell will sag and drain fast under real driving. A 7.4V or 11.1V LiPo pack — or a holder for a few AA cells wired for higher capacity — is the practical upgrade once the car is running and the wiring is confirmed to be correct.
Built and Backed by Compoden
Every part listed above ships from Compoden's India stock, so there's no long international wait on a motor driver or a Bluetooth module that turns out to be dead on arrival. Parts are checked for compatibility with the boards they're paired with before they're listed together in a build like this one. Orders typically arrive in 3-7 days, Cash on Delivery and UPI are both supported at checkout, and Compoden's support team is available if wiring or firmware issues come up while building.
Frequently asked questions
Does the HC-05 module come with this build automatically?
Not from a bare "build me a Bluetooth car" request — Compoden's storefront assistant filled every other role but flagged, in its own explanation, that the Arduino "has no built-in wireless features, so you will need to add a separate module for Bluetooth communication." The HC-05 is a real, in-stock part in Compoden's catalog and is included in the parts table above for that reason.
Can I use an HC-06 instead of an HC-05?
Yes, for this build's purposes. Both modules expose the same transparent serial bridge over classic Bluetooth; the practical difference is that the HC-05 can operate as either a master or a slave device while the HC-06 is slave-only. Since the phone always initiates the connection to the car, slave mode is all this build needs.
Why does the firmware use SoftwareSerial instead of the Arduino's built-in serial port?
Using SoftwareSerial on two spare digital pins (2 and 3, in the generated firmware) keeps the Uno's hardware serial port free for USB communication with a computer — useful for debugging over the Serial Monitor while the HC-05 handles the phone connection independently on its own pins.
Is a 9V battery enough to run the motors?
It's enough for a first test, but not for sustained driving. Two small DC motors plus an L298N driver can draw close to 5A combined at peak, well beyond what a 9V alkaline battery is built to sustain, and Compoden's own build assistant flagged this exact mismatch when it picked the battery. A 7.4V or 11.1V rechargeable pack sized for the motors' real current draw is the practical fix.