How to Connect Bluetooth to Arduino: HM-10 Wiring Diagram & Pinout

If you need to know how to connect Bluetooth to Arduino for a modern mobile app, the direct answer is to use a Bluetooth Low Energy (BLE) module like the HM-10, wire its VCC to the Arduino 5V pin, tie the grounds together, and cross the TX/RX data lines through a 5V-to-3.3V voltage divider. While legacy classic Bluetooth modules exist, modern iOS and Android ecosystems heavily restrict classic Serial Port Profile (SPP) connections, making BLE the mandatory path for 90% of new projects.

This guide walks through the exact schematic, traces the physical wiring node-by-node, and shows you how to verify the circuit with a multimeter before you ever plug in the USB cable.

The Module Decision Path: Why the HM-10 Wins

Before cutting wires, you must select the right silicon. The market is saturated with HC-05, HC-06, JDY-31, and HM-10 modules. Use this decision matrix to lock in your part number.

For the rest of this walkthrough, we are wiring the HM-10 (CC2541-based) to an Arduino Uno Rev3. We will use SoftwareSerial on pins 10 and 11 to leave the hardware UART (pins 0 and 1) free for USB debugging.

Decoding the Wiring Diagram Symbols

When looking at a standard UART wiring schematic, you will encounter four primary symbols. Understanding these prevents catastrophic miswiring.

• The Zig-Zag (Resistor): You will see two of these in series between the Arduino TX and the HM-10 RXD. This represents the voltage divider. The first resistor (R1) is typically 1kΩ, and the second (R2) dropping to ground is 2kΩ.
• Crossed Arrows (TX/RX): Transmit (TX) must always point to Receive (RX). If the diagram shows Arduino TX pointing to HM-10 TX, the diagram is wrong. Data flows out of a mouth and into an ear.
• The Ground Rake (Three descending horizontal lines): This indicates the common ground return path. It is not just a safety earth; it is the reference voltage for the UART logic signals. Without it, data is gibberish.
• VCC / VDD: Denotes the positive voltage supply node. On the HM-10, this accepts 3.6V to 6V due to an onboard LDO, meaning you can safely feed it 5V from the Arduino.

Node-by-Node Wiring Trace & Pin Mapping

Follow this physical trace from the source (Arduino) to the load (HM-10). Do not skip the voltage divider step; pushing 5V logic into the 3.3V-tolerant CC2541 RX pin will destroy the module.

Terminal Mapping Table

The Physical Trace

1. Node 1: Power Delivery (Polarity Check). Start at the Arduino 5V header. Connect a red jumper wire to the HM-10 VCC pin. The HM-10 has an onboard ME6211 3.3V LDO regulator, so it safely steps the 5V down to 3.3V for the internal radio. Polarity is strict here; reversing VCC and GND will short the supply and trip your PC's USB overcurrent protection.
2. Node 2: The Ground Return Path. Connect a black jumper wire from the Arduino GND pin to the HM-10 GND pin. This establishes the 0V reference plane. UART is a single-ended protocol; it measures voltage spikes relative to this exact ground node. If this wire is loose, your serial monitor will show garbage characters.
3. Node 3: The RX Signal (Load to Source). Connect a green wire directly from the HM-10 TXD pin to Arduino Pin 10. The HM-10 transmits at 3.3V, which the Arduino Uno's ATmega328P registers safely as a logic HIGH (anything above 3V is read as HIGH on a 5V board). No level shifting is required here.
4. Node 4: The TX Signal & Voltage Divider (Source to Load). This is the critical path. Solder or breadboard a 1kΩ resistor in series with a yellow wire coming from Arduino Pin 11. At the junction where the 1kΩ resistor meets the HM-10 RXD pin, connect a 2kΩ resistor dropping down to the common ground rail.
   Math check: $V_{out} = 5V imes (2000 / (1000 + 2000)) = 3.33V$. This safely shifts the 5V Arduino logic down to a 3.3V signal the HM-10 can digest.

Verifying the Connections with a Multimeter

Before uploading code or pairing a phone, grab your digital multimeter (DMM) and verify the physical layer. This three-step test catches 95% of wiring faults.

1. Verify the Ground Continuity: Set your DMM to the Continuity/Resistance mode (the diode/sound wave symbol). Place the black probe on the Arduino USB shield (which is tied to ground) and the red probe on the HM-10 GND pin. You should read less than 1.0 Ω and hear a beep. If it reads OL (Open Loop), your ground wire is broken or not seated in the breadboard.
2. Verify VCC Voltage: Switch the DMM to DC Voltage (20V range). Place the black probe on the HM-10 GND and the red probe on the HM-10 VCC. You must read between 4.8V and 5.2V. If you read 3.3V here, you accidentally wired VCC to the 3.3V Arduino pin, which cannot supply enough current to run the Bluetooth radio during transmission bursts.
3. Verify the TX Divider Output: Keep the DMM on DC Voltage. Move the red probe to the junction between the 1kΩ and 2kΩ resistors (the exact node feeding the HM-10 RXD). With the Arduino powered but idle (not actively sending serial data), the TX line sits HIGH. You should read ~3.3V. If you read 5V, your 2kΩ ground resistor is disconnected. If you read 0V, your 1kΩ series resistor is missing or the Arduino pin is misconfigured as an output LOW.

Common Wiring Faults and How to Fix Them

Even with a perfect schematic, embedded hardware throws curveballs. Here is how to troubleshoot the physical layer when the software fails.

Symptom: The HM-10 LED blinks, but the phone app sees no devices.

The Cause: The HM-10 defaults to BLE peripheral mode, but some cheap clones ship in AT Command mode or Central mode. Furthermore, iOS devices will never show BLE devices in the native iOS Bluetooth settings menu. Apple restricts the native menu to audio and MFi-certified classic devices.
The Fix: Download a dedicated BLE scanning app like LightBlue or nRF Connect on your phone. If it still doesn't appear, send the AT command AT+ROLE0 via the Arduino serial monitor to force the module back into Peripheral mode.

Symptom: Serial monitor outputs garbage characters (e.g., 'ÿÿÿ' or random symbols).

The Cause: Baud rate mismatch or a floating ground. The default baud rate for a factory-fresh HM-10 is 9600 bps. Some vendors flash them at 115200 bps.
The Fix: First, re-verify the ground continuity with your meter. If the ground is solid, change your SoftwareSerial initialization in code to 115200. If that fails, send AT+BAUD0 at 9600 to reset the module to factory defaults.

SoftwareSerial Initialization Block

To complete the circuit, your Arduino code must match the physical pin mapping. Use this exact initialization block to ensure the RX/TX swap is handled correctly in software:

#include <SoftwareSerial.h>

// Pin 10 is RX (connects to HM-10 TXD)
// Pin 11 is TX (connects to HM-10 RXD via voltage divider)
SoftwareSerial BTSerial(10, 11); 

void setup() {
  Serial.begin(9600);    // Hardware UART for PC debugging
  BTSerial.begin(9600);  // Software UART for HM-10 (Default baud)
  Serial.println('HM-10 Ready. Awaiting AT commands or data...');
}

void loop() {
  // Pass data from phone to PC monitor
  if (BTSerial.available()) {
    Serial.write(BTSerial.read());
  }
  // Pass data from PC monitor to phone
  if (Serial.available()) {
    BTSerial.write(Serial.read());
  }
}

By strictly following the node-by-node trace, respecting the 3.3V logic threshold with a physical voltage divider, and verifying the ground plane with a meter, you eliminate the physical variables. For further reading on the underlying radio silicon, consult the Texas Instruments CC2541 datasheet, and for software routing, review the official Arduino SoftwareSerial documentation.