Connessione al dispositivo Bluetooth dalla riga di comando

Sfondo: sto usando le mie cuffie bluetooth come uscita audio. Sono riuscito a farlo funzionare con il lungo elenco di istruzioni sulla documentazione della comunità BluetoothHeadset e ho automatizzato il processo di attivazione dell'auricolare come uscita audio predefinita in uno script, grazie a un'altra domanda .

Tuttavia, poiché utilizzo l'auricolare bluetooth sia con il mio telefono che con il computer (e l'auricolare non supporta due connessioni di ingresso) in modo che il telefono non "rubi" la connessione quando il portatile è acceso, forzo l'auricolare in un modalità di rilevamento durante la connessione al computer (il telefono si connette automaticamente ad esso).

Quindi, anche se l'auricolare è accoppiato correttamente e si connetterà automaticamente in uno scenario "normale", devo sempre utilizzare la piccola icona bluetooth nell'area di notifica per connettermi effettivamente al mio dispositivo (vedi screenshot).

Cosa voglio evitare: questa GUI per la connessione a un dispositivo Bluetooth noto e associato :

Quello che voglio invece: vorrei che il bluetooth facesse esattamente quello che fa il clic sull'elemento di connessione nella GUI, solo usando la riga di comando. Voglio usare la riga di comando in modo da poter creare una scorciatoia da tastiera per l'azione, e non avrei bisogno di navigare nella GUI ogni volta che voglio stabilire una connessione al dispositivo.

La domanda: come posso tentare di connettermi a un dispositivo bluetooth specifico, noto e associato dalla riga di comando?

Ulteriore domanda: come faccio a sapere se la connessione è andata a buon fine o no?

Demone Bluetooth

Nell'installazione predefinita un daemon ( bluetoothd ) viene eseguito in background (eseguito dal file /etc/init.d/bluetooth). Questo demone si occupa di riconoscere e connettersi a dispositivi bluetooth noti e può essere configurato con file di configurazione in /etc/bluetooth. Per il collegamento automatico di un auricolare, la seguente riga in audio.confdeve essere decommentata (rimuovi #):

AutoConnect=true

Per riavviare il tipo di demone sudo /etc/init.d/bluetooth restart.

_{Nota: l' uso dello strumento da riga di comando sudo hcitool cc <MAC-Adress>non ha portato a una connessione stabile a un dispositivo noto nell'ambiente di test qui quando il daemon era in esecuzione.}

DBus

Per connettere un auricolare disconnesso ma fisicamente presente e associato possiamo usare D-Bus da uno script. Ecco un esempio in Python:

#!/usr/bin/python
# Toggles headset connection

import dbus
from dbus.mainloop.glib import DBusGMainLoop

dbus_loop = DBusGMainLoop()
bus = dbus.SystemBus(mainloop=dbus_loop)

#Get dbus interface for headset
manager = bus.get_object('org.bluez', '/')
iface_m = dbus.Interface(manager, 'org.bluez.Manager')
adapterPath = iface_m.DefaultAdapter()
adapter = bus.get_object('org.bluez', adapterPath)
iface_a = dbus.Interface(adapter, 'org.bluez.Adapter')
devicePath = iface_a.ListDevices()[0]  # assuming first device
device = bus.get_object('org.bluez', devicePath)
iface_h = dbus.Interface(device, 'org.bluez.Headset')

#Check state of connection
connected = iface_h.IsConnected()
print 'Toggling connection. Please wait'
# toggle connection
if not connected:
    try:
        iface_h.Connect()
        print 'Connecting: ', devicePath
    except:
        print 'Device not found'
else:
    iface_h.Disconnect()
    print 'Disconnecting: ', devicePath

Nel caso in cui abbiamo più di un dispositivo Bluetooth, dovremo adattare in modo devicePathappropriato, ovviamente. L'esempio sopra collegherà a Headset. Cambia l'interfaccia con un protocollo diverso per qualsiasi altro servizio (es AudioSink.).

pulseaudio

Se conosci l'indirizzo MAC del tuo dispositivo Bluetooth puoi collegarlo come sink di uscita per pulseaudio:

pacmd set-default-sink bluez_sink.xx_xx_xx_xx_xx_xx

Dove xx_xx_xx_xx_xx_xx è l'indirizzo MAC (sostituire ":" con "_" affinché pulseaudio lo riconosca).

Vedi anche questa risposta per maggiori dettagli.

Uso questo script per collegare il mio dispositivo audio Bluetooth. Se l'auricolare è già associato, dovresti essere in grado di connetterlo allo stesso modo usando org.bluez.Headset.Connect / Disconnect al posto di org.bluez.Audiosink.Connect / Disconnect .

#!/bin/bash

MAC_ADD="C8:84:47:10:11:CD"

MAC_ADD="dev_${MAC_ADD//:/_}"
BT_ADAPTER=`dbus-send --system --print-reply --dest=org.bluez / \
org.bluez.Manager.DefaultAdapter|awk '/object path/ {print $3}'`

BT_ADAPTER="${BT_ADAPTER//\"/}/$MAC_ADD"
echo "Connecting to $BT_ADAPTER..."

if [ "$1" == "on" ]; then
    dbus-send --print-reply --system --dest=org.bluez $BT_ADAPTER org.bluez.AudioSink.Connect
elif [ "$1" == "off" ]; then
    dbus-send --print-reply --system --dest=org.bluez $BT_ADAPTER org.bluez.AudioSink.Disconnect
fi

HTH!

Uso i3 come gestore delle finestre, quindi non ho l'icona bluetooth nella barra delle applicazioni disponibile. Per qualche ragione il pulsante di controllo nelle impostazioni di unità non è sensibile e quindi ho bisogno di un modo per farlo di tanto in tanto quando le mie cuffie non si collegano.

Sembra che bluezabbia cambiato la loro API dbus . La risposta che utilizza org.bluez.Managernon sembra più funzionare. Invece, si consiglia di utilizzare ObjectManager.

Ecco uno script Python aggiornato che collegherà la prima cuffia bluetooth non connessa che trova (presumibilmente l'elenco comprende tutti i dispositivi associati?):

#!/usr/bin/env python
# Toggles headset connection

from __future__ import print_function
from __future__ import unicode_literals

import dbus
from dbus.mainloop.glib import DBusGMainLoop

def find_headset(bus):
  manager = dbus.Interface(bus.get_object("org.bluez", "/"),
                           "org.freedesktop.DBus.ObjectManager")
  objects = manager.GetManagedObjects()

  for path, ifaces in objects.items():
    if ("org.bluez.Device1" in ifaces and
        "org.freedesktop.DBus.Properties" in ifaces):
      iprops = dbus.Interface(
          bus.get_object("org.bluez", path),
          "org.freedesktop.DBus.Properties")
      props = iprops.GetAll("org.bluez.Device1")
      # Looking for a headset. Could also match on other properties like
      # "Name". See bluez docs for whats available.
      if props.get("Class") == 0x240404:
        if props.get("Connected"):
          print("Found headset {} ({}) but it is already connected"
                .format(props.get("Name"), props.get("Address")))
          continue
        return path

dbus_loop = DBusGMainLoop()
bus = dbus.SystemBus(mainloop=dbus_loop)
hpath = find_headset(bus)

if hpath:
  adapter = dbus.Interface(
      bus.get_object("org.bluez", hpath), "org.bluez.Device1")
  adapter.Connect()

questo esempio, come l'altro esempio su questo thread, usa il dbuspacchetto python. Su Ubuntu 16.04 ho installato questo tramite apt-get install python-dbus.

Se si desidera soddisfare altri criteri, questo documento sembra mostrare un elenco di proprietà che possono essere interrogate su dbus.

Ho salvato questo script nel ~/.local/bin/bt-connect-headsetmio, PATHcosì posso eseguirlo dal launcher i3. Renderlo eseguibile ( chmod +x bt-connect-headset) se si prevede di usarlo come comando.

Questo script è stato testato solo su Ubuntu 16.04 aggiornato al 28/09/2018.

Dopo aver provato alcuni dei precedenti (gli script non hanno funzionato per me) ho trovato la seguente soluzione.

Per prima cosa scopri l'indirizzo MAC del dispositivo a cui vuoi connetterti

bluetoothctl

questo entrerà in una shell ed elencherà tutti i dispositivi disponibili con indirizzo. ("esci" per uscire dalla shell e tornare al prompt)

Quindi connettersi a XX: XX: XX: XX: XX: XX dispositivo bluetooth:

echo -e 'connect XX:XX:XX:XX:XX:XX' | bluetoothctl

per disconnettersi

echo -e 'disconnect XX:XX:XX:XX:XX:XX' | bluetoothctl

sto cercando questo da un po 'di tempo - nulla sembrava funzionare, mi sono sentito così sollevato quando l'ho scoperto. Pensato che anche altri potrebbero volerlo sapere. :))