Android 4.3: jak połączyć się z wieloma urządzeniami Bluetooth Low Energy

Re: Problem z bluetooth-lowenergy na android : nadal używam opóźnień.

Koncepcja: po każdej większej akcji wywołującej BluetoothGattCallback (np. conenction, service discovery, write, read) potrzebna jest dealy. P. S. spójrz na przykład Google na BLE API level 19 przykład dla łączności , aby zrozumieć, jak powinny być wysyłane transmisje i uzyskać ogólne zrozumienie itp...

Po pierwsze, scan (lub scan) W poszukiwaniu urządzeń BluetoothDevices, należy wypełnić connectionQueue żądanymi urządzeniami i wywołać initConnection () .

Spójrz na poniższy przykład.

private Queue<BluetoothDevice> connectionQueue = new LinkedList<BluetoothDevice>();

public void initConnection(){
    if(connectionThread == null){
        connectionThread = new Thread(new Runnable() {
            @Override
            public void run() {
                connectionLoop();
                connectionThread.interrupt();
                connectionThread = null;
            }
        });

        connectionThread.start();
    }
}

private void connectionLoop(){
    while(!connectionQueue.isEmpty()){
        connectionQueue.poll().connectGatt(context, false, bleInterface.mGattCallback);
        try {
            Thread.sleep(250);
        } catch (InterruptedException e) {}
    }
}

public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
        switch(status){
            case BluetoothGatt.GATT_SUCCESS:
                if (newState == BluetoothProfile.STATE_CONNECTED) {
                    broadcastUpdate(BluetoothConstants.ACTION_GATT_CONNECTED, gatt);
                }else if(newState == BluetoothProfile.STATE_DISCONNECTED){
                    broadcastUpdate(BluetoothConstants.ACTION_GATT_DISCONNECTED, gatt);
                }
                break;
        }

    }
protected void broadcastUpdate(String action, BluetoothGatt gatt) {
    final Intent intent = new Intent(action);

    intent.putExtra(BluetoothConstants.EXTRA_MAC, gatt.getDevice().getAddress());

    sendBroadcast(intent);
}

P. S. sendBroadcast (intent) Może Trzeba zrobić tak:

Context context = activity.getBaseContext();
context.sendBroadcast(intent);

Wtedy transmisja jest odbierana przez BroadcastReceiver.onReceive(...)

public BroadcastReceiver myUpdateReceiver = new BroadcastReceiver(){

    @Override
    public void onReceive(Context context, Intent intent) {
        final String action = intent.getAction();
        if(BluetoothConstants.ACTION_GATT_CONNECTED.equals(action)){
            //Connection made, here you can make a decision: do you want to initiate service discovery.
            // P.S. If you are working with multiple devices, 
            // make sure that you start the service discovery 
            // after all desired connections are made
        }
        ....
    }
}

Po zrobieniu co chcesz w odbiorniku transmisji, oto jak kontynuuję:

private Queue<BluetoothGatt> serviceDiscoveryQueue = new LinkedList<BluetoothGatt>();

private void initServiceDiscovery(){
    if(serviceDiscoveryThread == null){
        serviceDiscoveryThread = new Thread(new Runnable() {
            @Override
            public void run() {
                serviceDiscovery();

                serviceDiscoveryThread.interrupt();
                serviceDiscoveryThread = null;
            }
        });

        serviceDiscoveryThread.start();
    }
}

private void serviceDiscovery(){
    while(!serviceDiscoveryQueue.isEmpty()){
        serviceDiscoveryQueue.poll().discoverServices();
        try {
            Thread.sleep(250);
        } catch (InterruptedException e){}
    }
}

private Queue<BluetoothGattCharacteristic> characteristicReadQueue = new LinkedList<BluetoothGattCharacteristic>();

private void startThread(){

    if(initialisationThread == null){
        initialisationThread = new Thread(new Runnable() {
            @Override
            public void run() {
                loopQueues();

                initialisationThread.interrupt();
                initialisationThread = null;
            }
        });

        initialisationThread.start();
    }

}

private void loopQueues() {

    while(!characteristicReadQueue.isEmpty()){
        readCharacteristic(characteristicReadQueue.poll());
        try {
            Thread.sleep(BluetoothConstants.DELAY);
        } catch (InterruptedException e) {}
    }
    // A loop for starting indications and all other stuff goes here!
}

Sam opracowuję aplikację z funkcjami BLE. Sposób, w jaki udało mi się połączyć z wieloma urządzeniami i włączyć powiadomienia, polegał na wdrożeniu opóźnień.

Więc robię nowy wątek (aby nie blokować wątku UI) i w nowym wątku połączyć i włączyć powiadomienia.

Na przykład po BluetoothDevice.connectGatt (); wywołanie wątku.sleep ();

I dodać to samo opóźnienie dla odczytu/zapisu i włączenia/wyłączenia powiadomień.

EDIT

Użyj wait tak, że Android dindn ' t reaise ANR

public static boolean waitIdle() {
        int i = 300;
        i /= 10;
        while (--i > 0) {
            if (true)
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        }

        return i > 0;
    }

Rain ma rację w jego odpowiedzi, trzeba Opóźnienia dla prawie wszystkiego, gdy pracujesz z BLE w Androidzie. Opracowałem z nim kilka aplikacji i jest to naprawdę konieczne. Korzystając z nich unikasz wielu awarii.

W moim przypadku używam opóźnień po każdym poleceniu odczytu/zapisu. W ten sposób niemal zawsze otrzymujesz odpowiedź z urządzenia BLE. Robię coś takiego: (oczywiście wszystko jest robione w osobnym wątku, aby uniknąć dużo pracy na głównej thread)

 readCharacteristic(myChar);
 try {
    Thread.sleep(100);
 } catch (InterruptedException e) {
    e.printStackTrace();
 }
 myChar.getValue();

Lub:

 myChar.setValue(myByte);
 writeCharacteristic(myChar);
 try {
    Thread.sleep(100);
 } catch (InterruptedException e) {
    e.printStackTrace();
 }

Jest to bardzo przydatne, gdy czytasz / zapisujesz kilka cech pod rząd... Ponieważ Android jest wystarczająco szybki, aby wykonać polecenia niemal natychmiast, jeśli nie użyjesz opóźnienia między nimi, możesz uzyskać błędy lub niespójne wartości...

Mam nadzieję, że to pomoże, nawet jeśli nie jest to dokładnie odpowiedź na twoje pytanie.

Niestety powiadomienia w bieżącym stosie Androida BLE są nieco błędne. Istnieją pewne twarde limity i znalazłem pewne problemy ze stabilnością nawet w przypadku pojedynczego urządzenia. (Czytałem w pewnym momencie, że można mieć tylko 4 powiadomienia... nie jestem pewien, czy dotyczy to wszystkich urządzeń, czy każdego urządzenia. Próbuję znaleźć źródło tych informacji.)

Spróbowałbym przełączyć się na pętlę ankietową (powiedzmy, przepytaj przedmioty w pytaniu 1 / sek) i sprawdzić, czy Twoja stabilność wzrasta. Ja bym rozważ również przejście na inne urządzenie slave (powiedzmy HRM lub TI SensorTag), aby sprawdzić, czy nie występuje problem z kodem po stronie slave (chyba że możesz przetestować go na iOS lub innej platformie i potwierdzić, że nie jest częścią problemu).

Edytuj: odniesienie do ograniczenia zgłoszenia