Integrando Una Báscula Bluetooth en Home Assistant: Mi Experiencia Y Resultados

¿Te has preguntado alguna vez cómo integrar una báscula Bluetooth económica en tu sistema domótico sin depender de aplicaciones móviles? En este artículo te comparto mi experiencia integrando una báscula Bluetooth Swisshome con Home Assistant utilizando un ESP32 y ESPHome.

Lo mejor de este proyecto es que no necesitas ninguna aplicación adicional: simplemente interceptamos las emisiones Bluetooth que lanza la báscula y las enviamos directamente a Home Assistant para crear un sistema de monitoreo de peso completamente integrado.

¿Por qué este proyecto?

Las básculas inteligentes comerciales suelen requerir:

• Aplicaciones móviles específicas
• Cuentas en la nube
• Suscripciones premium
• Dependencia de servicios externos

Con esta solución obtenemos:

• Control total sobre nuestros datos
• Integración nativa con Home Assistant
• Automatizaciones personalizadas
• Costo mínimo (báscula económica + ESP32)

Requisitos del proyecto

Hardware necesario

• Báscula Bluetooth Swisshome (o compatible)
• ESP32 (cualquier modelo con Bluetooth)
• Cable USB para programar el ESP32
• Fuente de alimentación para el ESP32

Software requerido

• Home Assistant funcionando
• ESPHome instalado (como complemento o standalone)
• Editor de código (VS Code recomendado)

Conocimientos básicos

• Conceptos básicos de Home Assistant
• Nociones de YAML
• Uso básico de ESPHome

¿Cómo funciona la báscula?

La báscula Swisshome transmite automáticamente paquetes de datos por Bluetooth Low Energy (BLE) que incluyen:

• Peso corporal (en gramos)
• Impedancia corporal (en ohmios)
• Estado de la medición (en progreso/completada)

Protocolo de comunicación

Los datos se transmiten en paquetes manufacturados con las siguientes características:

• Company ID: 0xA0AC (identificador único)
• Encriptación: XOR con clave derivada del Company ID
• Tipos de paquete:
  • 0xAD → Peso corporal
  • 0xA6 → Impedancia corporal
• Checksum: Verificación de integridad de datos

Configuración paso a paso

1. Identificar la MAC de tu báscula

Primero necesitamos encontrar la dirección MAC de nuestra báscula. Puedes usar aplicaciones como nRF Connect (Android/iOS) o Bluetooth Scanner para identificarla.

# Configuración temporal para encontrar la MAC
esp32_ble_tracker:
  scan_parameters:
    interval: 1100ms
    window: 1100ms
    active: true
  on_ble_advertise:
    - then:
        - lambda: |-
            ESP_LOGD("ble_adv", "MAC: %s, RSSI: %d", x.address_str().c_str(), x.get_rssi());

2. Configuración completa de ESPHome

Aquí está la configuración completa que uso en mi ESP32:

# Configuración básica del ESP32
esphome:
  name: bascula-bluetooth
  platform: ESP32
  board: esp32dev

# Configuración WiFi
wifi:
  ssid: "TU_WIFI_SSID"
  password: "TU_WIFI_PASSWORD"
  
  # Punto de acceso de emergencia
  ap:
    ssid: "Bascula Fallback"
    password: "12345678"

# Configuración de red
captive_portal:

# API para Home Assistant
api:
  encryption:
    key: "tu_clave_api_generada_automaticamente"

# OTA para actualizaciones remotas
ota:
  password: "tu_password_ota"

# Configuración del logger
logger:
  level: DEBUG
  logs:
    ble_adv: DEBUG

# Sensores template para mostrar los datos
sensor:
  - platform: template
    name: "Peso Báscula"
    id: weight_sensor
    unit_of_measurement: "kg"
    accuracy_decimals: 2
    icon: "mdi:weight-kilogram"
    device_class: "weight"
    state_class: "measurement"
    
  - platform: template
    name: "Impedancia Corporal"
    id: body_impedancia_sensor
    unit_of_measurement: "Ω"
    accuracy_decimals: 1
    icon: "mdi:flash"
    state_class: "measurement"
    
  - platform: template
    name: "Señal Bluetooth Báscula"
    id: rssi_sensor
    unit_of_measurement: "dBm"
    accuracy_decimals: 0
    icon: "mdi:bluetooth"
    device_class: "signal_strength"
    state_class: "measurement"


# Configuración Bluetooth
esp32_ble_tracker:
  scan_parameters:
    interval: 1100ms
    window: 1100ms
    active: true
  on_ble_advertise:
    - mac_address:
        - XX:XX:XX:XX:XX:XX  # Reemplaza por la MAC de tu báscula
      then:
        - lambda: |-
            // Actualizar estado de conectividad
            id(scale_active).publish_state(true);
            id(rssi_sensor).publish_state(x.get_rssi());
            
            // Constantes del protocolo
            const uint16_t company_id = 0xA0AC;
            int xor_key = company_id >> 8;

            // Procesar datos del fabricante
            for (auto data : x.get_manufacturer_datas()) {
              if (data.data.size() >= 12) {
                ESP_LOGD("ble_adv", "Datos recibidos: %s", 
                         format_hex_pretty(data.data).c_str());
                
                // Decodificar datos (aplicar XOR)
                std::vector<uint8_t> buf(6);
                for (int i = 0; i < 6; i++) {
                  buf[i] = data.data[i + 6] ^ xor_key;
                }

                // Verificar checksum
                int chk = 0;
                for (int i = 0; i < 5; i++) {
                  chk += buf[i];
                }

                if ((chk & 0x1F) != (buf[5] & 0x1F)) {
                  ESP_LOGW("ble_adv", "Error de checksum");
                  return;
                }

                // Procesar según tipo de paquete
                uint8_t packet_type = buf[4];
                
                if (packet_type == 0xAD) {
                  // Paquete de peso
                  int32_t value = (buf[3] | (buf[2] << 8) | (buf[1] << 16) | (buf[0] << 24));
                  uint8_t state = (value >> 31) & 0x1;
                  int grams = value & 0x3FFFF;
                  float weight_kg = grams / 1000.0;

                  ESP_LOGD("ble_adv", "Peso: %.2f kg, Estado: %s", 
                           weight_kg, state ? "Completado" : "Midiendo");
                  
                  // Solo publicar cuando la medición esté completa
                  if (state != 0) {
                    id(weight_sensor).publish_state(weight_kg);
                    ESP_LOGI("ble_adv", "Medición de peso completada: %.2f kg", weight_kg);
                  }
                  
                } else if (packet_type == 0xA6) {
                  // Paquete de impedancia
                  int impedancia_raw = ((buf[1]) << 8) | buf[0];
                  float impedancia = impedancia_raw / 10.0;
                  
                  ESP_LOGD("ble_adv", "Impedancia: %.1f Ω", impedancia);
                  id(body_impedancia_sensor).publish_state(impedancia);
                  
                } else {
                  ESP_LOGD("ble_adv", "Tipo de paquete desconocido: 0x%02X", packet_type);
                }
              }
            }

3. Compilación y carga del firmware

Una vez configurado el archivo YAML:

1. Compila el firmware desde ESPHome
2. Conecta el ESP32 al PC via USB
3. Carga el firmware (primera vez por cable, luego OTA)
4. Verifica los logs para asegurar que funciona correctamente

Troubleshooting y problemas comunes

Problema: El ESP32 no detecta la báscula

Posibles causas y soluciones:

1. MAC incorrecta: Verifica la dirección MAC con un escáner Bluetooth
2. Distancia: Acerca el ESP32 a la báscula (máximo 2-3 metros)
3. Interferencias: Aleja otros dispositivos Bluetooth
4. Báscula en standby: Pisa la báscula para activarla

Problema: Los datos no llegan a Home Assistant

Soluciones:

1. Verifica la API key en la configuración
2. Revisa los logs del ESP32 para ver si hay errores
3. Comprueba la conexión WiFi del ESP32
4. Reinicia Home Assistant para refrescar la integración

Problema: Valores incorrectos o erráticos

Posibles causas:

1. Company ID destinto al 0xA0AC: actualizar el company id que emite tu basuca el el codigo yaml en const uint16_t company_id = 0xA0AC;
2. Superficie irregular: Coloca la báscula en superficie plana y dura
3. Calibración: Algunas básculas requieren calibración inicial
4. Interferencias electromagnéticas: Aleja de microondas, routers, etc.
5. Checksum fallido: Revisa los logs para errores de integridad

Ventajas y limitaciones

Ventajas del proyecto

• Privacidad total: Datos locales sin nube
• Integración nativa: Funciona perfectamente con Home Assistant
• Bajo costo: Menos de 15€ total
• Personalizable: Automatizaciones y cálculos a medida
• Confiable: Protocolo Bluetooth estable

Conclusión

La integración de una báscula Bluetooth económica con Home Assistant es un proyecto fascinante que demuestra el potencial de la domótica DIY. Con menos de 30€ y unas horas de configuración, tienes un sistema de monitoreo de peso completamente integrado en tu hogar inteligente.

Lo que más me gusta de esta solución es el control total sobre los datos y la capacidad de crear automatizaciones personalizadas. Ya no dependes de aplicaciones móviles ni servicios en la nube, y puedes expandir las funcionalidades según tus necesidades.

Si tienes una báscula Swisshome o compatible, te animo a probar este proyecto. Es una excelente manera de aprender sobre protocolos Bluetooth, ESPHome y la integración de dispositivos IoT caseros.

¿Has implementado algo similar? ¿Tienes alguna mejora que sugerir? Comparte tu experiencia en los comentarios, me encantaría conocer tus adaptaciones y optimizaciones.

Nota: Este proyecto es educativo y experimental. Siempre verifica la compatibilidad con tu modelo específico de báscula antes de implementarlo.