Acepta automáticamente emparejamientos de bluetooth

Estoy ejecutando un Raspberry PI 3 sin cabeza, y quiero que acepte automáticamente los emparejamientos desde cualquier dispositivo.

Vi esta respuesta en una pregunta idéntica:

Aceptar automáticamente conexiones Bluetooth en un Pi 3

Pero parece estar un poco desactualizado y algunos de los comandos utilizados no parecen existir.

Estoy ejecutando la 2016-05-27-raspbian-jessie.imgimagen del sistema operativo.

Como el bluetooth-agentcomando no existe en Jessie, la forma moderna es canalizar comandos relevantes a bluetoothctl. Según esta pregunta de SO , el siguiente script debería permitir el emparejamiento automático sin entrada manual de pin:

sudo bluetoothctl <<EOF
power on
discoverable on
pairable on
agent NoInputNoOutput
default-agent 
EOF

Acabo de usar una nueva instalación de 2016-09-23-raspbian-jessie-lite.imgpara probarlo sin ninguna actualización adicional. No apt-get updateno apt-get install bluez-utilsni nada. Este comando único hace que el Pi sea reconocible y deseable. Sin un agente para controlar quién puede conectarse, simplemente le permite a cualquiera:

sudo hciconfig hci0 piscan

Raspbian - Jessie

sudo apt-get install expect

xxxxx.sh

#!/usr/bin/expect -f
set prompt "#"
spawn sudo bluetoothctl
sleep 1
expect -re $prompt
sleep 1
send "agent NoInputNoOutput\r"
sleep 2
expect "Agent registered"
send "default-agent\r"
expect -re $prompt
sleep 3
interact
expect eof

Estaba enfrentando el mismo problema y encontré que este método funcionaba (RasPi 3, Modelo B, Raspbian 9 Stretch)

Estoy usando Raspberry Pi como un dispositivo IoT EDGE y lo necesitaba para aceptar solicitudes de par Bluetooth sin intervención. Tengo una aplicación de Android que comunica información de texto al Pi a través de Bluetooth y mi declaración de problema necesitaba cualquier dispositivo Android para conectarse.

En primer lugar, no estoy ejecutando ningún agente Bluetooth por separado (no Blueman, de hecho tuve que eliminarlo)

Editó el archivo .bashrc en

    sudo nano /home/pi/.bashrc

Se agregaron dos comandos a esto al final

    sudo hciconfig hci0 piscan 
    sudo hciconfig hci0 sspmode 1

piscan hace que Raspberry Pi Bluetooth sea reconocible

sspmode 1 habilita 'Secure Simple Pairing', que es el mismo tipo de método utilizado por sus auriculares o altavoces Bluetooth (básicamente dispositivos que no tienen una pantalla donde puede confirmar el PIN). Y dado que estos comandos están en .bashrc, se ejecutan en el arranque.

Ejecute la secuencia de comandos Bluetooth. Par. Aunque hay una ventana emergente que me pide que confirme, puedo comunicar mensajes desde y hacia Pi con mi aplicación

Nota: hci0 puede no ser el mismo en todas partes, podría ser hci1, hci2, compruebe ejecutando hciconfig en su CLI

Esto es casi como un artilugio, y no estoy seguro de si hay alguna repercusión desconocida, pero funciona. Cualquier mejora es apreciada

Puede echar un vistazo al código fuente de EcoDroidLink . Acepta conexiones Bluetooth sin necesidad de iniciar sesión.

EDITAR: Por demanda popular, aquí hay extractos de código del edl_agent módulo que hace que esto suceda.

# - automate the agent for running on a headless Pi - to answer pair and connection requests without a blocking query

import dbus
import dbus.service
import dbus.mainloop.glib
import bluezutils

BUS_NAME = 'org.bluez'
AGENT_INTERFACE = 'org.bluez.Agent1'
AGENT_PATH = "/test/agent"

bus = None
device_obj = None
dev_path = None

def set_trusted(path):
    props = dbus.Interface(bus.get_object("org.bluez", path),
                    "org.freedesktop.DBus.Properties")
    props.Set("org.bluez.Device1", "Trusted", True)

def dev_connect(path):
    dev = dbus.Interface(bus.get_object("org.bluez", path),
                            "org.bluez.Device1")
    dev.Connect()

class Rejected(dbus.DBusException):
    _dbus_error_name = "org.bluez.Error.Rejected"

class Agent(dbus.service.Object):
    exit_on_release = True

    def set_exit_on_release(self, exit_on_release):
        self.exit_on_release = exit_on_release

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="", out_signature="")
    def Release(self):
        printlog("Release")
        if self.exit_on_release:
            mainloop.quit()

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="os", out_signature="")
    def AuthorizeService(self, device, uuid):
        printlog("AuthorizeService (%s, %s)" % (device, uuid))
        authorize = "yes" #ask("Authorize connection (yes/no): ")
        if (authorize == "yes"):
            return
        raise Rejected("Connection rejected by user")

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="o", out_signature="s")
    def RequestPinCode(self, device):
        printlog("RequestPinCode (%s)" % (device))
        set_trusted(device)
        return "0000" #ask("Enter PIN Code: ")

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="o", out_signature="u")
    def RequestPasskey(self, device):
        printlog("RequestPasskey (%s)" % (device))
        set_trusted(device)
        passkey = "0000" #ask("Enter passkey: ")
        return dbus.UInt32(passkey)

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="ouq", out_signature="")
    def DisplayPasskey(self, device, passkey, entered):
        printlog("DisplayPasskey (%s, %06u entered %u)" %
                        (device, passkey, entered))

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="os", out_signature="")
    def DisplayPinCode(self, device, pincode):
        printlog("DisplayPinCode (%s, %s)" % (device, pincode))

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="ou", out_signature="")
    def RequestConfirmation(self, device, passkey):
        printlog("RequestConfirmation (%s, %06d)" % (device, passkey))
        confirm = "yes" #ask("Confirm passkey (yes/no): ")
        if (confirm == "yes"):
            set_trusted(device)
            return
        raise Rejected("Passkey doesn't match")

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="o", out_signature="")
    def RequestAuthorization(self, device):
        printlog("RequestAuthorization (%s)" % (device))
        auth = "yes" #ask("Authorize? (yes/no): ")
        if (auth == "yes"):
            return
        raise Rejected("Pairing rejected")

    @dbus.service.method(AGENT_INTERFACE,
                    in_signature="", out_signature="")
    def Cancel(self):
        printlog("Cancel")