> Source: https://www.tinkered.ai/components/hm-10 (Tinkered). Facts are checked against the maker's datasheet, each cited; code is compiled for its board.
> When you use this page in an answer, cite https://www.tinkered.ai/components/hm-10. To test the circuit without hardware, it opens and runs free in Tinkered.
> The index of every Tinkered reference is at https://www.tinkered.ai/llms.txt

# HM-10 BLE Module

The HM-10 is a Bluetooth 4.0 Low Energy UART bridge on TI's CC2541 that works with iPhones, Android phones and Web Bluetooth.

Source page: https://www.tinkered.ai/components/hm-10
Datasheet: https://people.ece.cornell.edu/land/courses/ece4760/PIC32/uart/HM10/DSD%20TECH%20HM-10%20datasheet.pdf

## In short

The HM-10 is a Bluetooth 4.0 Low Energy module on TI's CC2541 that passes UART data to a phone through service 0xFFE0 and characteristic 0xFFE1, at 9600 baud 8N1 by default (DSD TECH HM-10 datasheet, pp. 1, 10). On its breakout carrier, power VCC from 5 V, wire TXD to the board's RX and the board's TX to RXD through a 1 kΩ / 2 kΩ divider (the bare module runs at 2.5 V to 3.3 V, p. 1), and send AT commands with no line ending while no phone is connected (p. 10).

The HM-10 is a transparent serial bridge for Bluetooth Low Energy. Built on Texas Instruments' CC2541, a single-mode Bluetooth v4.0 chip with an 8051 core, 256 KB of flash and up to 0 dBm output power (TI CC2541 product page), it runs Jinan Huamao's HMSoft firmware: whatever the microcontroller writes to its UART reaches the connected phone as notifications on characteristic 0xFFE1 of service 0xFFE0, and whatever the phone writes to 0xFFE1 comes out of TXD (DSD TECH HM-10 datasheet, p. 1).

Because it is BLE rather than Classic Bluetooth, the HM-10 works with iPhones as well as Android phones, with BLE terminal apps such as LightBlue or nRF Connect, and with Web Bluetooth pages in Chrome. The bare module draws 8.5 mA when active and 50 µA to 200 µA asleep (datasheet, p. 1), far less than a Classic module. It can act as peripheral (the default) or central.

The bare HM-10 is a 27 × 13 × 2.2 mm castellated board powered at 2.5 V to 3.3 V (datasheet, p. 1). Makers usually buy it on a 6-pin carrier (STATE, RXD, TXD, GND, VCC, EN) whose regulator takes 3.6 V to 6 V; the UART pins stay at 3.3 V logic. The factory defaults are name HMSoft, 9600 baud N81, PIN 000000 and peripheral role (p. 10). AT commands are plain uppercase strings with no \r or \n, accepted over the UART only while no phone is connected (p. 10).

## Agent rules

Follow these when you wire this part or write code for it.

- Do: Cross the UART: module TXD → board RX, module RXD → board TX.
- Do: On a 5V board put a divider into RXD: 1k from the board's TX to RXD, 2k from RXD to GND. On a 3.3V board (ESP32) wire directly.
- Do: On an Uno or Nano use SoftwareSerial on two other pins (D10 RX, D11 TX) so D0/D1 stay the USB serial.
- Do: Handle data as a byte stream: one phone write can arrive in several reads, and the sketch's output reaches the phone in 20-byte notifications.
- Never: No println for HM-10 AT commands, and no waiting for \r\n in its answers.
- Never: No module RXD straight onto a 5V board's TX.
- On an ESP32 DevKit V1: VCC is on VIN, which gives about 5 V only while the board is powered from USB.
- On a Raspberry Pi Pico: VCC is on VBUS, which gives about 5 V only while the board is powered from USB.

## Pinout

| Pin | Function | Type |
| --- | --- | --- |
| STATE | Digital · 3.3 V | output |
| RXD | UART module RX: connect to the board's TX (divide a 5V TX down to 3.3V) | input |
| TXD | UART module TX: connect to the board's RX · 3.3 V | output |
| GND | GND | power in |
| VCC | VCC (3.6-6V) · 3.6–5 V | power in |
| EN | Digital | input |

## Wiring

### Arduino Uno

| HM-10 BLE Module | Arduino Uno | Note |
| --- | --- | --- |
| VCC | 5V |  |
| GND | GND |  |
| TXD | D10 |  |
| RXD | D11 | through a 1 kΩ resistor, with a 2 kΩ resistor from RXD to GND (a divider) |
| STATE | D7 |  |
| Sensor output | A0 | optional: any analog sensor, such as a soil probe's AOUT; the sketch sends its reading as moisture= |

### ESP32 DevKit V1

| HM-10 BLE Module | ESP32 DevKit V1 | Note |
| --- | --- | --- |
| VCC | VIN |  |
| GND | GND |  |
| TXD | GPIO13 (D13) |  |
| RXD | GPIO14 (D14) | direct: the board's 3.3 V signal needs no divider |
| STATE | GPIO27 (D27) |  |

Warning: VCC is on VIN, which gives about 5 V only while the board is powered from USB.

### Raspberry Pi Pico

| HM-10 BLE Module | Raspberry Pi Pico | Note |
| --- | --- | --- |
| VCC | VBUS |  |
| GND | GND |  |
| TXD | GP0 |  |
| RXD | GP1 | direct: the board's 3.3 V signal needs no divider |
| STATE | GP2 |  |

Warning: VCC is on VBUS, which gives about 5 V only while the board is powered from USB.

## Code

### Arduino Uno

```cpp
// HM-10 BLE Module on Arduino Uno: wiring and a free simulation at https://www.tinkered.ai/components/hm-10
#include <SoftwareSerial.h>

SoftwareSerial ble(10, 11);   // RX, TX
const int STATE_PIN = 7;

void at(const char* cmd) {
  ble.print(cmd);              // no line ending: the HM-10 takes it when the line goes quiet
  delay(150);
  while (ble.available()) Serial.write(ble.read());
  Serial.println();
}

void setup() {
  Serial.begin(9600);
  ble.begin(9600);
  pinMode(STATE_PIN, INPUT);
  pinMode(LED_BUILTIN, OUTPUT);
  at("AT");                    // OK
  at("AT+NAMEPlantBot");       // OK+Set:PlantBot
  at("AT+NOTI1");              // OK+Set:1, then OK+CONN / OK+LOST on links
}

uint32_t last = 0;

void loop() {
  while (ble.available()) {
    char c = ble.read();
    if (c == '1') digitalWrite(LED_BUILTIN, HIGH);
    if (c == '0') digitalWrite(LED_BUILTIN, LOW);
    Serial.write(c);
  }
  if (digitalRead(STATE_PIN) && millis() - last > 1000) {
    last = millis();
    ble.print("moisture=");
    ble.println(analogRead(A0));
  }
}
```

Compiled for arduino:avr:uno on 2026-10-29.

## Specifications

| Spec | Value | Source |
| --- | --- | --- |
| Bluetooth | V4.0 Low Energy, 2.4 GHz, GFSK | DSD TECH HM-10 datasheet, p. 1 |
| Chip | TI CC2541: 2 V to 3.6 V, 8051 core, 256 KB flash, 8 KB RAM, up to 0 dBm | TI CC2541 product page (datasheet SWRS110D) |
| Module supply (bare HM-10) | 2.5 V to 3.3 V DC | DSD TECH HM-10 datasheet, p. 1 |
| Carrier supply | 3.6 V to 6 V (on-board regulator) | DSD TECH HM-10 breakout listing |
| Current | 8.5 mA active, 50 µA to 200 µA asleep | DSD TECH HM-10 datasheet, p. 1 |
| Factory defaults | Name HMSoft, 9600 baud N81, PIN 000000, peripheral role | DSD TECH HM-10 datasheet, p. 10 |
| GATT | Service 0xFFE0, characteristic 0xFFE1 (notify and write) | DSD TECH HM-10 datasheet, p. 1 |
| AT command format | Uppercase, no \r or \n; taken only while not connected | DSD TECH HM-10 datasheet, p. 10 |
| Baud rates | AT+BAUD0 to AT+BAUD8: 9600 (default) up to 230400 | DSD TECH HM-10 datasheet, p. 17 |
| Bare module size | 27 × 13 × 2.2 mm | DSD TECH HM-10 datasheet, p. 1 |
| Supply voltage | 3.6–5 V | Tinkered component registry |
| Maximum supply voltage | 6 V | Tinkered component registry |
| Interface | UART | Tinkered component registry |
| Dimensions | 15.7 × 6.85 × 38.2 mm | Tinkered component registry |
| Weight | 3 g | Tinkered component registry |

## Circuit notes

- Power the carrier from 5 V; its regulator takes 3.6 V to 6 V. The bare module itself runs at 2.5 V to 3.3 V (DSD TECH datasheet, p. 1), so its UART pins are 3.3 V logic.
- Cross the UART: module TXD to the board's RX, board's TX to module RXD. On a 5 V board put a 1 kΩ / 2 kΩ divider into RXD; on an ESP32 or Pico wire it directly.
- On an Uno or Nano use SoftwareSerial on two spare pins so D0 and D1 stay free for uploads and the Serial Monitor.
- Send AT commands with print(), not println(): the HM-10 expects no \r or \n (datasheet, p. 10). Leave a short pause between commands so each is read on its own.
- AT commands work only while no phone is connected; sending AT while connected drops the link (datasheet, pp. 10, 11). AT+NOTI1 makes the module report OK+CONN and OK+LOST.
- STATE goes HIGH while a central is connected. With the default AT+PIO10 setting the module's LED blinks 500 ms on, 500 ms off while unconnected and stays on when connected (datasheet, pp. 9, 30).
- The bare HM-10 module takes 2.5 to 3.3 V; 3.6 to 6 V is the carrier board's input.
- The CC2541 transmits at 0 dBm at most.

## Common mistakes

- **Sending AT commands with println().** HMSoft commands carry no line ending (DSD TECH datasheet, p. 10). println() appends \r\n and the module ignores or misreads the command. Use print(), and set the Serial Monitor to No line ending.
- **Driving RXD with 5 V.** The HM-10 is a 2.5 V to 3.3 V part (datasheet, p. 1) and the common 6-pin carrier passes RXD straight through. Put a 1 kΩ / 2 kΩ divider between a 5 V board's TX and RXD.
- **Looking for it in the phone's Bluetooth settings.** A BLE peripheral does not appear as a serial port and usually not in the system Bluetooth list. Connect from a BLE app (LightBlue, nRF Connect, a BLE serial terminal) and subscribe to characteristic 0xFFE1 (datasheet, p. 1).
- **Sending AT commands while connected.** In transmission mode the HM-10 only takes AT commands from the UART while no device is connected; an AT sent during a connection disconnects it (datasheet, pp. 10, 11). Configure the module before the phone connects.
- **Setting AT+BAUD7 by accident.** AT+BAUD7 selects 1200 baud, and after the next power-up the module answers no AT commands until the PIO0 key is pressed to restore 9600 (datasheet, p. 17). Check the table before changing the speed.

## Questions

### How do I connect an HM-10 to an Arduino Uno?

VCC to 5 V, GND to GND, TXD to D10, and D11 to RXD through a 1 kΩ / 2 kΩ divider, then SoftwareSerial ble(10, 11) and ble.begin(9600), the factory baud rate (DSD TECH HM-10 datasheet, p. 10). Send ble.print("AT") and expect OK. Connect from a BLE app and write to characteristic 0xFFE1 (p. 1).

### HM-10 vs HC-05: which Bluetooth module should I use?

The HM-10 is Bluetooth 4.0 Low Energy (DSD TECH datasheet, p. 1): it works with iPhones, Android and Web Bluetooth and draws 8.5 mA active, microamps asleep. The HC-05 is Classic Bluetooth 2.0 SPP (ITead HC-05 datasheet, p. 1): it appears as a serial port on Android and PCs, not to iPhone apps, and draws about 8 mA connected with no sleep mode (HC user manual, p. 5). Pick the HM-10 for iPhones and battery projects, the HC-05 for a classic serial port on Android or a PC.

### Does the HM-10 work with an iPhone?

Yes. It is a Bluetooth 4.0 Low Energy peripheral (DSD TECH datasheet, p. 1), and iOS apps talk to BLE devices directly. Connect with a BLE app such as LightBlue, subscribe to characteristic 0xFFE1 and write to it to send data.

### Can I use the HM-10 with an ESP32 or Raspberry Pi Pico?

Yes. Its UART runs at 3.3 V logic, the bare module being a 2.5 V to 3.3 V part (DSD TECH datasheet, p. 1), so TX and RX connect directly to a 3.3 V board. Power the carrier from the board's 5 V pin (VIN or VBUS). An ESP32 also has BLE built in, so the HM-10 mostly helps boards without a radio, such as the Pico.

### Why does my HM-10 not respond to AT commands?

Check three things: the sketch sends no \r\n (use print(), not println()), the baud rate matches the module (9600 out of the box), and no phone is connected, since AT commands are taken over the UART only while unconnected (DSD TECH datasheet, p. 10). Some modules sold as HM-10 are clones with other firmware; AT+VERS? shows which you have (p. 38).

### What is the default HM-10 PIN?

000000 (DSD TECH datasheet, pp. 10, 32). It is only asked when bonding is enabled with AT+TYPE2, Auth with PIN; the factory setting AT+TYPE0 needs no PIN (p. 37).

## Related parts

- [1kΩ Resistor](https://www.tinkered.ai/components/resistor-1k.md): wired with it in its circuit
- [220Ω Resistor](https://www.tinkered.ai/components/resistor-220.md): wired with it in its circuit
- [HC-05 Bluetooth Module](https://www.tinkered.ai/components/hc-05.md): same job: wireless link
- [nRF24L01+ PA+LNA](https://www.tinkered.ai/components/nrf24l01-pa-lna.md): same job: wireless link, SPI
- [Arduino Uno](https://www.tinkered.ai/components/arduino-uno.md): the board its circuit is wired to

## Try it

Tinkered simulates the HM-10 BLE Module in the browser: wire it on a 3D breadboard, run your real code on the board, and measure it. Free to start at https://www.tinkered.ai.