Accetta automaticamente gli accoppiamenti bluetooth

Sono in esecuzione un Raspberry PI 3 senza testa e voglio che accetti automaticamente gli accoppiamenti da qualsiasi dispositivo.

Ho visto questa risposta in una domanda identica:

Accettazione automatica delle connessioni Bluetooth su un Pi 3

Ma sembra essere un po 'obsoleto e alcuni dei comandi usati non sembrano esistere.

Sto eseguendo l' 2016-05-27-raspbian-jessie.imgimmagine del sistema operativo.

Dal momento che il bluetooth-agentcomando non esiste su Jessie, il modo moderno è reindirizzare i comandi rilevanti bluetoothctl. Sulla base di questa domanda SO , il seguente script dovrebbe abilitare l'associazione automatica senza l'inserimento manuale dei pin:

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

Ho appena usato una nuova installazione di 2016-09-23-raspbian-jessie-lite.imgper provarlo senza ulteriori aggiornamenti. No apt-get updateno apt-get install bluez-utilso niente. Questo singolo comando rende il Pi rilevabile e abbinabile. Senza un agente per controllare chi può connettersi, consente a chiunque:

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

Stavo affrontando lo stesso problema e ho trovato questo metodo funzionante (RasPi 3, Modello B, Raspbian 9 Stretch)

Sto usando Raspberry Pi come dispositivo EDGE EDT e ne avevo bisogno per accettare richieste di accoppiamento Bluetooth senza intervento. Ho un'app Android che comunica le informazioni di testo al Pi tramite Bluetooth e la mia dichiarazione di problema aveva bisogno di qualsiasi dispositivo Android per connettersi.

In primo luogo, non eseguo agenti Bluetooth separati (No Blueman, infatti ho dovuto rimuoverlo)

Modificato il file .bashrc in

    sudo nano /home/pi/.bashrc

Aggiunti due comandi a questo alla fine

    sudo hciconfig hci0 piscan 
    sudo hciconfig hci0 sspmode 1

piscan rende Raspberry Pi Bluetooth rilevabile

sspmode 1 abilita 'Secure Simple Pairing' che è lo stesso tipo di metodo utilizzato dagli auricolari o dagli altoparlanti Bluetooth (in pratica i dispositivi che non dispongono di un display in cui è possibile confermare il PIN). E poiché questi comandi sono in .bashrc, vengono eseguiti all'avvio.

Esegui script Bluetooth. Paio. Anche se c'è un popup che mi chiede di confermare, posso comunicare messaggi da e verso il Pi con la mia app

Nota: hci0 potrebbe non essere lo stesso dappertutto, potrebbe essere hci1, hci2 si prega di verificare eseguendo hciconfig sulla CLI

Questo è quasi come un aggeggio, e non sono sicuro se ci siano ripercussioni sconosciute, ma funziona. Eventuali miglioramenti sono apprezzati

Puoi dare un'occhiata al codice sorgente di EcoDroidLink . Accetta connessioni Bluetooth senza la necessità di accedere.

EDIT: A grande richiesta, ecco alcuni estratti di codice del edl_agent modulo che rendono possibile questo.

# - 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")