Accepter automatiquement les couplages Bluetooth

J'utilise un Raspberry PI 3 sans tête et je veux qu'il accepte automatiquement les appariements de n'importe quel appareil.

J'ai vu cette réponse dans une question identique:

Accepter automatiquement les connexions Bluetooth sur un Pi 3

Mais cela semble un peu dépassé et certaines des commandes utilisées ne semblent pas exister.

J'exécute l' 2016-05-27-raspbian-jessie.imgimage du système d'exploitation.

Étant donné que la bluetooth-agentcommande n'existe pas sur Jessie, la méthode moderne consiste à diriger les commandes pertinentes vers bluetoothctl. Sur la base de cette question SO , le script suivant devrait permettre le couplage automatique sans entrée manuelle des broches:

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

Je viens d'utiliser une nouvelle installation de 2016-09-23-raspbian-jessie-lite.imgpour l'essayer sans aucune mise à jour supplémentaire. Non apt-get updatenon apt-get install bluez-utilsou rien. Cette commande unique rend le Pi détectable et jumelable. Sans agent pour contrôler qui peut se connecter, il permet simplement à n'importe qui:

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

J'étais confronté au même problème et j'ai trouvé que cette méthode fonctionnait (RasPi 3, modèle B, Raspbian 9 Stretch)

J'utilise Raspberry Pi en tant qu'appareil IoT EDGE et j'en avais besoin pour accepter les demandes de paires Bluetooth sans intervention. J'ai une application Android qui communique des informations textuelles au Pi via Bluetooth et mon énoncé de problème avait besoin de n'importe quel appareil Android pour se connecter.

Tout d'abord, je n'exécute aucun agent Bluetooth séparé (pas de Blueman, en fait j'ai dû le supprimer)

Modifié le fichier .bashrc à

    sudo nano /home/pi/.bashrc

Ajout de deux commandes à cela à la fin

    sudo hciconfig hci0 piscan 
    sudo hciconfig hci0 sspmode 1

piscan rend le Raspberry Pi Bluetooth découvrable

sspmode 1 active le «couplage simple sécurisé», qui est le même type de méthode utilisé par vos écouteurs ou haut-parleurs Bluetooth (essentiellement des appareils qui n'ont pas d'écran où vous pouvez confirmer le code PIN). Et puisque ces commandes sont en .bashrc, elles s'exécutent au démarrage.

Exécutez le script Bluetooth. Paire. Bien qu'une fenêtre contextuelle me demande de confirmer, je peux communiquer des messages vers et depuis le Pi avec mon application.

Remarque: hci0 peut ne pas être le même partout, pourrait être hci1, hci2 veuillez vérifier en exécutant hciconfig sur votre CLI

C'est presque comme un engin, et je ne sais pas s'il y a des répercussions inconnues, mais cela fonctionne. Toutes les améliorations sont appréciées

Vous pouvez jeter un œil au code source d' EcoDroidLink . Il accepte les connexions Bluetooth sans avoir besoin de se connecter.

EDIT: À la demande générale, voici des extraits de code du edl_agent module qui rend cela possible.

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