Programa en Python que calcula la distancia estimada a la que se encuentra un dispositivo BLE (Bluetooth Low Energy), analiza información sobre el dispostivo BLE y envía un mensaje al dispositivo cercano con características escribibles (usando handle)

Python, Radio

Contenidos

Enlaces interesantes sobre el tema
Programa en Python que calcula la distancia estimada a la que se encuentra un dispositivo BLE (Bluetooth Low Energy), analiza información sobre el dispostivo BLE y envía un mensaje al dispositivo cercano con características escribibles (usando handle)

Enlaces interesantes sobre el tema

import asyncio
from bleak import BleakScanner, BleakClient
from bleak.backends.device import BLEDevice

# Reemplaza esto con el mensaje que deseas enviar
MESSAGE = "Hola"

# RSSI de referencia a 1 metro (usualmente entre -59 y -65 dBm)
RSSI_REFERENCE = -59
# Factor de propagación (n)
PROPAGATION_CONSTANT = 2

def calculate_distance(rssi, reference=RSSI_REFERENCE, n=PROPAGATION_CONSTANT):
    """
    Calcula la distancia estimada en metros basada en el RSSI.
    :param rssi: La intensidad de la señal recibida en dBm.
    :param reference: RSSI de referencia a 1 metro (en dBm).
    :param n: Factor de propagación.
    :return: La distancia estimada en metros.
    """
    if rssi == 0:
        return float('inf')  # La distancia no puede calcularse si RSSI es 0
    return 10 ** ((reference - rssi) / (10 * n))

async def scan_for_devices():
    """Escanea dispositivos BLE y devuelve una lista de dispositivos encontrados."""
    print("Escaneando dispositivos BLE...")
    devices = await BleakScanner.discover()
    return devices

async def connect_and_send_message(device, message):
    """Conecta al dispositivo BLE y envía un mensaje a cada handle de características que soporten escritura."""
    try:
        async with BleakClient(device) as client:
            print(f"Conectado a {device.name or 'Desconocido'} ({device.address})")
            try:
                services = await client.get_services()
                for service in services:
                    print(f"Servicio: {service.uuid}")
                    for characteristic in service.characteristics:
                        properties = characteristic.properties
                        print(f"  Característica: {characteristic.uuid} - Propiedades: {properties}")

                        if "write" in properties:
                            try:
                                # Utilizar el handle para enviar el mensaje
                                handle = characteristic.handle
                                await client.write_gatt_char(handle, message.encode('utf-8'))
                                print(f"Mensaje '{message}' enviado a la característica con handle {handle}.")
                            except Exception as e:
                                print(f"Error al enviar mensaje a la característica con handle {handle}: {e}")
            except Exception as e:
                print(f"Error al obtener servicios: {e}")
    except Exception as e:
        print(f"Error al conectar con el dispositivo {device.name or 'Desconocido'}: {e}")

async def main():
    devices = await scan_for_devices()

    if not devices:
        print("No se encontraron dispositivos BLE.")
        return

    for device in devices:
        # Extraer RSSI directamente del objeto device
        rssi = device.rssi  # Suponemos que el dispositivo BLE proporciona el RSSI correctamente
        
        # Calcular distancia estimada
        distance = calculate_distance(rssi)
        
        # Formatear la salida
        distance_str = f"{distance:.2f} metros" if distance != float('inf') else "No disponible"
        name = device.name or "Desconocido"
        address = device.address or "Desconocido"
        
        # Información del dispositivo
        print(f"\n-------------------------------")
        print(f"Dispositivo encontrado: {name}")
        print(f"  Dirección (MAC): {address}")
        print(f"  RSSI: {rssi} dBm - Distancia estimada: {distance_str}")

        # Información adicional sobre el dispositivo
        if 'advertisement' in device.metadata:
            advertisement = device.metadata['advertisement']
            if 'manufacturer_data' in advertisement:
                manufacturer_data = advertisement['manufacturer_data']
                for company_id, data in manufacturer_data.items():
                    print(f"  Datos del fabricante (Company ID {company_id}): {data.hex()}")
            if 'local_name' in advertisement:
                print(f"  Nombre local: {advertisement['local_name']}")
            if 'tx_power_level' in advertisement:
                print(f"  Nivel de potencia TX: {advertisement['tx_power_level']} dBm")

        # Conectar y enviar mensaje
        await connect_and_send_message(device, MESSAGE)

        # Separador para cada dispositivo
        print("\n" + "-"*50 + "\n")

# Ejecutar el escaneo y el envío de mensajes
asyncio.run(main())

100

101

import asyncio

from bleak import BleakScanner, BleakClient

from bleak.backends.device import BLEDevice

# Reemplaza esto con el mensaje que deseas enviar

MESSAGE = "Hola"

# RSSI de referencia a 1 metro (usualmente entre -59 y -65 dBm)

RSSI_REFERENCE = -59

# Factor de propagación (n)

PROPAGATION_CONSTANT = 2

def calculate_distance(rssi, reference=RSSI_REFERENCE, n=PROPAGATION_CONSTANT):

"""

Calcula la distancia estimada en metros basada en el RSSI.

:param rssi: La intensidad de la señal recibida en dBm.

:param reference: RSSI de referencia a 1 metro (en dBm).

:param n: Factor de propagación.

:return: La distancia estimada en metros.

"""

if rssi == 0:

return float('inf') # La distancia no puede calcularse si RSSI es 0

return 10 ** ((reference - rssi) / (10 * n))

async def scan_for_devices():

"""Escanea dispositivos BLE y devuelve una lista de dispositivos encontrados."""

print("Escaneando dispositivos BLE...")

devices = await BleakScanner.discover()

return devices

async def connect_and_send_message(device, message):

"""Conecta al dispositivo BLE y envía un mensaje a cada handle de características que soporten escritura."""

try:

async with BleakClient(device) as client:

print(f"Conectado a {device.name or 'Desconocido'} ({device.address})")

try:

services = await client.get_services()

for service in services:

print(f"Servicio: {service.uuid}")

for characteristic in service.characteristics:

properties = characteristic.properties

print(f" Característica: {characteristic.uuid} - Propiedades: {properties}")

if "write" in properties:

try:

# Utilizar el handle para enviar el mensaje

handle = characteristic.handle

await client.write_gatt_char(handle, message.encode('utf-8'))

print(f"Mensaje '{message}' enviado a la característica con handle {handle}.")

except Exception as e:

print(f"Error al enviar mensaje a la característica con handle {handle}: {e}")

except Exception as e:

print(f"Error al obtener servicios: {e}")

except Exception as e:

print(f"Error al conectar con el dispositivo {device.name or 'Desconocido'}: {e}")

async def main():

devices = await scan_for_devices()

if not devices:

print("No se encontraron dispositivos BLE.")

return

for device in devices:

# Extraer RSSI directamente del objeto device

rssi = device.rssi # Suponemos que el dispositivo BLE proporciona el RSSI correctamente

# Calcular distancia estimada

distance = calculate_distance(rssi)

# Formatear la salida

distance_str = f"{distance:.2f} metros" if distance != float('inf') else "No disponible"

name = device.name or "Desconocido"

address = device.address or "Desconocido"

# Información del dispositivo

print(f"\n-------------------------------")

print(f"Dispositivo encontrado: {name}")

print(f" Dirección (MAC): {address}")

print(f" RSSI: {rssi} dBm - Distancia estimada: {distance_str}")

# Información adicional sobre el dispositivo

if 'advertisement' in device.metadata:

advertisement = device.metadata['advertisement']

if 'manufacturer_data' in advertisement:

manufacturer_data = advertisement['manufacturer_data']

for company_id, data in manufacturer_data.items():

print(f" Datos del fabricante (Company ID {company_id}): {data.hex()}")

if 'local_name' in advertisement:

print(f" Nombre local: {advertisement['local_name']}")

if 'tx_power_level' in advertisement:

print(f" Nivel de potencia TX: {advertisement['tx_power_level']} dBm")

# Conectar y enviar mensaje

await connect_and_send_message(device, MESSAGE)

# Separador para cada dispositivo

print("\n" + "-"*50 + "\n")

# Ejecutar el escaneo y el envío de mensajes

asyncio.run(main())

Programa en Python que calcula la distancia estimada a la que se encuentra un dispositivo BLE (Bluetooth Low Energy), analiza información sobre el dispostivo BLE y envía un mensaje al dispositivo cercano con características escribibles (usando handle) (Radio, Python)

Enlaces interesantes sobre el tema

Programa en Python que calcula la distancia estimada a la que se encuentra un dispositivo BLE (Bluetooth Low Energy), analiza información sobre el dispostivo BLE y envía un mensaje al dispositivo cercano con características escribibles (usando handle)

LIBRO DE POWERSHELL

LO ÚLTIMO

VÍDEOS