This is an automated archive made by the Lemmit Bot.
The original was posted on /r/homeassistant by /u/ForsakenSyllabub8193 on 2025-05-30 14:38:54+00:00.
Hey everyone! I just wanted to share my recent deep dive into integrating my Alpha BT bathroom scale with Home Assistant, using an ESP32 and ESPHome. Full disclosure: I'm pretty new to Bluetooth protocols, so if you spot something that could be done better or more efficiently, please, please let me know! My goal here is to help others who might be facing similar challenges with unsupported devices and to get some feedback from the community.
I picked up a "smart" scale (the Alpha BT) for basic weight tracking. As soon as I got it, the usual story unfolded: a proprietary app demanding every permission, cloud-only data storage, and zero compatibility with Home Assistant. Plus, it wasn't supported by well-known alternatives like OpenScale. That's when I decided to roll up my sleeves and see if I could wrestle my data back into my own hands.
Step 1: Sniffing Out the Bluetooth Communication with nRF Connect
My first move was to understand how the scale was talking to its app. I thought nRF Connect Android app would work but since my scale only advertised when i stood on it it dint work instead i had to go to the alpha bt app and then get the mac from there then go to my ras pi and using btmon i had to filter for that mac and see the signals.
The logs were a waterfall of hex strings, but after some observation, a pattern emerged: a single hex string was broadcast continuously from the scale.(i used gemini 2.5 pro for this as it was insanely complicated so it did a good job)
It looked something like this (your exact string might vary, but the structure was key):
XX-XX-XX-XX-XX-XX-XX-XX-XX-XX-XX-XX (I'm using placeholders for the fixed parts)
Watching the logs, three key things became apparent:
- Most of the bytes stayed constant.
- Specific bytes changed frequently. For my scale, the 9th and 10th bytes in the sequence (
data.data[8] and data.data[9] if we start counting from 0) were constantly updating. Converting these two bytes (big-endian) to decimal and dividing by 100 gave me the accurate weight in kilograms.
- The 3rd byte (
data.data[2]) was interesting. It seemed to toggle between values like 01, 02, and 03. When the weight was stable, this byte consistently showed 02. This was my indicator for stability.
- I also found a byte for battery percentage (for me, it was
data.data[4]). This might differ for other scales, so always double-check with your own device's advertisements!
I didn't bother trying to figure out what every single byte did, as long as I had the crucial weight, stability, and battery data. The main goal was to extract what I needed!
Step 2: Crafting the ESPHome Configuration
With the data points identified, the next challenge was getting them into Home Assistant. ESPHome on an ESP32 seemed like the perfect solution to act as a BLE bridge. After much trial and error, piecing together examples, and a lot of Googling, I came up with this YAML configuration:
esphome:
name: alpha-scale-bridge
friendly_name: Alpha BT Scale Bridge
# NEW: ESP32 Platform definition (important for newer ESPHome versions)
esp32:
board: esp32dev
# You can optionally specify the framework, Arduino is the default if omitted.
# framework:
# type: arduino
# WiFi Configuration
wifi:
ssid: "YOUR_WIFI_SSID" # Replace with your WiFi SSID
password: "YOUR_WIFI_PASSWORD" # Replace with your WiFi Password
# Fallback hotspot in case main WiFi fails
ap:
ssid: "Alpha-Scale-Bridge"
password: "12345678"
# Enable captive portal for easier initial setup if WiFi fails
captive_portal:
# Enable logging to see what's happening
logger:
level: INFO
# Enable Home Assistant API (no encryption for simplicity, but encryption_key is recommended for security!)
api:
ota:
platform: esphome
# Web server for basic debugging (optional, can remove if not needed)
web_server:
port: 80
# BLE Tracker configuration and data parsing
esp32_ble_tracker:
scan_parameters:
interval: 1100ms # How often to scan
window: 1100ms # How long to scan within the interval
active: true # Active scanning requests scan response data
on_ble_advertise:
# Replace with YOUR scale's MAC address!
- mac_address: 11:0C:FA:E9:D8:E2
then:
- lambda: |-
// Loop through all manufacturer data sections in the advertisement
for (auto data : x.get_manufacturer_datas()) {
// Check if the data size is at least 13 bytes as expected for our scale
if (data.data.size() >= 13) {
// Extract weight from the first two bytes (bytes 0 and 1, big-endian)
uint16_t weight_raw = (data.data[0] << 8) | data.data[1];
float weight_kg = weight_raw / 100.0; // Convert to kg (e.g., 8335 -> 83.35)
// Extract status byte (byte 2)
uint8_t status = data.data[2];
bool stable = (status & 0x02) != 0; // Bit 1 indicates stability (e.g., 0x02 if stable)
bool unit_kg = (status & 0x01) != 0; // Bit 0 might indicate unit (0x01 for kg, verify with your scale)
// Extract sequence counter (byte 3)
uint8_t sequence = data.data[3];
//
***
Battery data extraction (YOU MAY NEED TO ADJUST THIS FOR YOUR SCALE)
***
// Assuming battery percentage is at byte 4 (data.data[4])
if (data.data.size() >= 5) { // Ensure the data is long enough
uint8_t battery_percent = data.data[4];
id(alpha_battery).publish_state(battery_percent);
}
// ---------------------------------------------------------------------
// Only update sensors if weight is reasonable (e.g., > 5kg to filter noise) and unit is kg
if (weight_kg > 5.0 && unit_kg) {
id(alpha_weight).publish_state(weight_kg);
id(alpha_stable).publish_state(stable);
// Set status text based on 'stable' flag
std::string status_text = stable ? "Stable" : "Measuring";
id(alpha_status).publish_state(status_text.c_str());
// Update last seen timestamp using Home Assistant's time
id(alpha_last_seen).publish_state(id(homeassistant_time).now().strftime("%Y-%m-%d %H:%M:%S").c_str());
// Log the reading for debugging in the ESPHome logs
ESP_LOGI("alpha_scale", "Weight: %.2f kg, Status: 0x%02X, Stable: %s, Seq: %d, Battery: %d%%",
weight_kg, status, stable ? "Yes" : "No", sequence, battery_percent);
}
}
}
# Sensor definitions for Home Assistant to display data
sensor:
- platform: template
name: "Alpha Scale Weight"
id: alpha_weight
unit_of_measurement: "kg"
device_class: weight
state_class: measurement
accuracy_decimals: 2
icon: "mdi:scale-bathroom"
- platform: template
name: "Alpha Scale Battery"
id: alpha_battery
unit_of_measurement: "%"
device_class: battery
state_class: measurement
icon: "mdi:battery"
binary_sensor:
- platform: template
name: "Alpha Scale Stable"
id: alpha_stable
device_class: connectivity # Good choice for stable/unstable state
text_sensor:
- platform: template
name: "Alpha Scale Status"
id: alpha_status
- platform: template
name: "Alpha Scale Last Seen"
id: alpha_last_seen
# Time component to get current time from Home Assistant for timestamps
time:
- platform: homeassistant
id: homeassistant_time
Explaining the ESPHome Code in Layman's Terms:
esphome: and esp32:: This sets up the basic info for our device and tells ESPHome we're using an ESP32 board. A recent change meant platform: ESP32 moved from under esphome: to its own esp32: section.wifi:: Standard Wi-Fi setup so your ESP32 can connect to your home network. The ap: section creates a temporary Wi-Fi hotspot if the main connection fails, which is super handy for initial setup or debugging.api:: This is how Home Assistant talks to your ESP32. I've kept it simple without encryption for now, but usually, an encryption_key is recommended for security.esp32_ble_tracker:: This is the heart of the BLE sniffing. It tells the ESP32 to constantly scan for Bluetooth advertisements.
on_ble_advertise:: This is the magic part! It says: "When you see a Bluetooth advertisement from a specific MAC address (your scale's), run this custom C++ code."lambda:: This is where our custom C++ code goes. It iterates through the received Bluetooth data.
data.data[0], data.data[1], etc., refer to the individual bytes in the raw advertisement string.- The
(data.data[0] << 8) | data.data[1] part is a bit shift. In super simple terms, this takes two 8-bit numbers (bytes) and combines them into a single 16-bit number. Think of it like taking the first two digits of a two-digit number (e.g., 83 from 8335) and making it the first part of a bigger number, then adding the next two digits (35) to form 8335. It's how two bytes are read as one larger v...
Content cut off. Read original on https://old.reddit.com/r/homeassistant/comments/1kz5w7j/how_i_hacked_my_smart_weighing_scale_to_work_with/
