web-dev-qa-db-fra.com

Associez des périphériques Bluetooth à un ordinateur avec la bibliothèque Bluetooth .NET 32 pieds

Si vous souhaitez savoir comment utiliser la bibliothèque 32feet.NET pour communiquer avec des périphériques Bluetooth, lisez la solution

J'essaie actuellement de communiquer via Bluetooth entre un ordinateur et un prototype .NET Gadgeteer auto-construit.

Le prototype Gadgeteer se compose de la carte mère, d'une alimentation et d'un module Bluetooth. Le module est en mode détectable.

Sur l'ordinateur, un programme Bluetooth personnalisé basé sur 32 pieds Bluetooth .NET est en cours d'exécution. Le programme détecte tous les appareils Bluetooth à portée et essaie de les associer. Cependant, cela ne se fait pas automatiquement pour le moment, je dois entrer un code de couplage pour l'appareil.

Comment puis-je coupler des appareils sans entrer le code de couplage?

Des périphériques sont détectés, le problème est la partie de couplage. J'ai beaucoup expérimenté, mais je n'ai pas trouvé de solution ...

foreach (BluetoothDeviceInfo device in this.deviceList)
{
    try
    {
        //BluetoothClient client = new BluetoothClient(this.CreateNewEndpoint(localAddress));
        //BluetoothEndPoint ep = this.CreateNewEndpoint(device.DeviceAddress);

        EventHandler<BluetoothWin32AuthenticationEventArgs> handler = new EventHandler<BluetoothWin32AuthenticationEventArgs>(HandleRequests);
        BluetoothWin32Authentication auth = new BluetoothWin32Authentication(handler);

        BluetoothSecurity.PairRequest(device.DeviceAddress, null);
    }
}

Ce bloc de code lance le couplage et cela fonctionne, mais Windows me demande d'entrer le code de couplage pour l'appareil. J'ai lu des informations sur BluetoothWin32Authentication pour éviter ce cas, mais je ne comprends pas bien.

private void HandleRequests(object that, BluetoothWin32AuthenticationEventArgs e)
{
    e.Confirm = true;
}

Il s'agit du code du gestionnaire d'événements ( http://32feet.codeplex.com/wikipage?title=BluetoothWin32Authentication )

Si vous souhaitez simplement autoriser le couplage lorsque SSP se connectent, la gestion du rappel et la définition de e.Confirm = True seront suffisantes - mais c'est un peu incertain .. .

Je suis confus -.- Le but est que l'application et le module gadgeteer puissent envoyer des données dans les deux sens sans aucune intervention de l'utilisateur.

Est-il vrai que je ne peux pas coupler automatiquement les appareils sans interaction avec l'utilisateur?

Est-il vrai que si deux appareils étaient déjà couplés, ils peuvent échanger des données sans interaction avec l'utilisateur?

c#bluetooth32feet.net-gadgeteer
26
xmashallax

J'ai compris comment résoudre mes problèmes et mes connaissances sur les connexions Bluetooth sont un peu plus importantes maintenant. Si quelqu'un d'autre a des problèmes avec cela, je fournis ma solution. Les exemples de code représentent l'implémentation C # d'un contrôleur Bluetooth avec la bibliothèque Bluetooth 32 pieds.

Numérisation

Cela signifie que les appareils à portée sont détectés. Mon code:

// mac is mac address of local bluetooth device
BluetoothEndPoint localEndpoint = new BluetoothEndPoint(mac, BluetoothService.SerialPort);
// client is used to manage connections
BluetoothClient localClient = new BluetoothClient(localEndpoint);
// component is used to manage device discovery
BluetoothComponent localComponent = new BluetoothComponent(localClient);
// async methods, can be done synchronously too
localComponent.DiscoverDevicesAsync(255, true, true, true, true, null);
localComponent.DiscoverDevicesProgress += new EventHandler<DiscoverDevicesEventArgs>(component_DiscoverDevicesProgress);
localComponent.DiscoverDevicesComplete += new EventHandler<DiscoverDevicesEventArgs>(component_DiscoverDevicesComplete);

private void component_DiscoverDevicesProgress(object sender, DiscoverDevicesEventArgs e)
{
    // log and save all found devices
    for (int i = 0; i < e.Devices.Length; i++)
    {           
        if (e.Devices[i].Remembered)
        {
            Print(e.Devices[i].DeviceName + " (" + e.Devices[i].DeviceAddress + "): Device is known");
        }
        else
        {
            Print(e.Devices[i].DeviceName + " (" + e.Devices[i].DeviceAddress + "): Device is unknown");
        }
        this.deviceList.Add(e.Devices[i]);         
    }
}

private void component_DiscoverDevicesComplete(object sender, DiscoverDevicesEventArgs e)
{
    // log some stuff
}

Pairage

Cela signifie que les appareils sont couplés avec l'appareil Bluetooth local. Cela doit être fait une fois en entrant un code des deux côtés. Peut être fait via du code afin que l'utilisateur ne remarque même pas qu'un appareil a été ajouté. Mon code à cet effet:

// get a list of all paired devices
BluetoothDeviceInfo[] paired = localClient.DiscoverDevices(255, false, true, false, false);
// check every discovered device if it is already paired 
foreach (BluetoothDeviceInfo device in this.deviceList)
{
    bool isPaired = false;
    for (int i = 0; i < paired.Length; i++)
    {
        if (device.Equals(paired[i]))
        {
            isPaired = true;
            break;
        }
    }

    // if the device is not paired, pair it!
    if (!isPaired)
    {
        // replace DEVICE_PIN here, synchronous method, but fast
        isPaired = BluetoothSecurity.PairRequest(device.DeviceAddress, DEVICE_PIN);
        if (isPaired)
        {
            // now it is paired
        }
        else
        {
            // pairing failed
        }
    }
}

Connexion

Cela signifie établir une connexion et échanger des données. Encore un peu de code:

// check if device is paired
if (device.Authenticated)
{
    // set pin of device to connect with
    localClient.SetPin(DEVICE_PIN);
    // async connection method
    localClient.BeginConnect(device.DeviceAddress, BluetoothService.SerialPort, new AsyncCallback(Connect), device);
}

// callback
private void Connect(IAsyncResult result)
{
    if (result.IsCompleted)
    {
        // client is connected now :)
    }
}

Si vous conservez la numérisation, l'association, la connexion, tout devrait fonctionner correctement. Pour envoyer ou recevoir des données, utilisez la méthode GetStream() de BluetoothClient. Il fournit un flux réseau qui peut être manipulé.

Réception d'une connexion

Si vous souhaitez qu'un autre appareil se connecte à votre appareil, vous devez écouter les demandes de connexion entrantes. Cela ne fonctionne que si l'appareil a déjà été couplé auparavant. Mon code:

BluetoothListener l = new BluetoothListener(LOCAL_MAC, BluetoothService.SerialPort);
l.Start(10);
l.BeginAcceptBluetoothClient(new AsyncCallback(AcceptConnection), l);

void AcceptConnection(IAsyncResult result){
    if (result.IsCompleted){
        BluetoothClient remoteDevice = ((BluetoothListener)result.AsyncState).EndAcceptBluetoothClient(result);    
    }    
}

Remplacez LOCAL_MAC Par une adresse Bluetooth valide (par exemple en utilisant BluetoothAddress.Parse();). Une fois les appareils connectés, ils peuvent échanger des messages via le flux sous-jacent. Si la connexion ne fonctionne pas, il peut y avoir des problèmes d'authentification, essayez donc de définir la broche du périphérique local dans l'écouteur (l.SetPin(LOCAL_MAC, MY_PASSWORD);

42
xmashallax