Communication série Bluetooth fluide sur Raspberry Pi 2 avec Windows 10 IoT Core

Composants et fournitures

Composant	Quantité
Raspberry Pi 2 Modèle B	1
Dongle USB Bluetooth générique	1
Arduino UNO	1
Module Bluetooth SparkFun BlueSMiRF Silver	1

Applications et services en ligne

• Microsoft Windows 10 IoT Core
• Microsoft Visual Studio 2015

À propos de ce projet

Ce projet est discuté en détail sur embedded101.com : « Win 10 IoT-Core: Bluetooth Universal Windows Serial App ».

À propos

Il s'agit d'une application universelle Windows (UWP) qui connecte un dispositif IoT Core (Raspberry Pi 2) à un dispositif Bluetooth embarqué via le profil série Bluetooth (SPP) à l'aide d'un dongle USB Bluetooth générique.

Contexte

Bluetooth permet une mise en réseau pair-à-pair à courte portée. Contrairement au Wi-Fi, la connexion Bluetooth est un-à-un : deux appareils se connectent et interagissent. Par exemple, deux appareils peuvent se connecter de manière symétrique via le profil série et échanger des données brutes. Généralement, la connectivité Bluetooth est asymétrique : une extrémité génère un format de données spécifique consommé par l'autre (ex: téléphone avec profil A2DP streaming audio vers un casque HSP). OBEX (Object Exchange) est une connexion symétrique d'échange de données.

L'exemple Microsoft IoT-Core Bluetooth utilise le profil GATT (Generic Attribute Profile) pour la découverte et la description de services Bluetooth Low Energy. Ce projet est beaucoup plus simple : il ne concerne que le profil SPP (Serial Port Profile) basé sur RFCOMM. Développé avec un vieux dongle USB Bluetooth, il devrait fonctionner avec n'importe quel dongle.

L'application IoT

C'est une application de test série Bluetooth universelle Windows 10. Elle énumère (sous forme de liste) tous les appareils Bluetooth appariés au dispositif. On en sélectionne un par double-clic pour initier la connexion. Le texte à envoyer est saisi dans une zone de texte et envoyé par bouton. L'application reçoit automatiquement tout texte entrant et l'affiche. Ainsi, si le point final renvoie simplement l'écho du texte reçu, le texte envoyé réapparaît dans la zone de réception.

Le point final (Endpoint)

Pour les tests, on utilise un Arduino Uno avec un adaptateur Bluetooth. Un sketch simple fait écho à tout caractère reçu via la connexion Bluetooth :

Configuration du shield :

// Application de boucle série (loopback)
// Initialisée par le système connecté
// Utilisable avec Bluetooth où Rx/Tx du module BT
// sont connectés à Tx/Rx de l'Arduino.
// Il faut déconnecter l'adaptateur BT pour programmer.
void setup() {
  // Mon adaptateur est réglé à ce BAUD 115200
  // C'est le débit Arduino vers adaptateur BT
  // Réglé quand l'adaptateur est en mode commande.
  // Ce n'est PAS le débit BT qu'on ne peut pas régler.
  Serial.begin(115200);
  delay(333);
  while (!Serial) ;
  delay(1000);
  Serial.println("The quick brown fox jumps over the lazy dog!");
}

Boucle du shield :

void loop() {
  char ch = Serial.read();
  while (255 == (byte) ch) {
    ch = Serial.read();
  }
  Serial.print(ch);
}

Appairage

Bluetooth est un scénario pair-à-pair. Avant de se connecter, les appareils doivent être appariés. Cela ne se fait pas dans l'application. L'appairage avec code d'accès peut être problématique entre appareils embarqués souvent sans écran (headless) et ne supportant pas les popups (IoT Core ne les supporte pas). Il existe un portail web IoT Core et un utilitaire en ligne de commande sur l'appareil (accessible via SSH) pour cela. La version la plus récente du portail web de l'OS supporte l'appairage par code d'accès, absent à l'époque de Windows 10 RTM. L'article « Win 10 IoT-Core: Bluetooth Universal Windows Serial App » traite l'appairage en détail.

Démarrage du projet

Le projet d'application est créé dans Visual Studio 2015 avec le modèle « Blank App (Universal Windows) » :

Nouveau projet → Visual C# → Windows → Blank App (Universal Windows)

Création de l'interface utilisateur

L'UI est implémentée en XAML :

• Tous les éléments de texte sont des TextBlock sauf SendText qui est un TextBox.
• SendText accepte les retours chariot (multiligne).
• Recvd a WrapText activé (multiligne).
• Les éléments UI sont organisés en lignes via des StackPanel à orientation horizontale, eux-mêmes empilés dans un StackPanel vertical avec la ListBox.
• On peut aussi utiliser RelativePanel ou Grid.

ConnectDevices est une ListBox avec ItemsSource lié à PairedDevices et un ItemTemplate contenant un TextBlock lié à la propriété Name de PairedDevices :

<ListBox x:Name="ConnectDevices" ItemsSource="{Binding Source={StaticResource PairedDevices}}" Margin="10" DoubleTapped="ConnectDevices_DoubleTapped" Width="Auto" Height="Auto">
  <ListBox.ItemTemplate>
    <DataTemplate>
      <TextBlock Text="{Binding Name}" />
    </DataTemplate>
  </ListBox.ItemTemplate>
</ListBox>

Configuration de l'application

• L'application n'utilise pas de fonctionnalités IoT Core spécifiques, pas besoin de références d'extension.
• Des capacités Bluetooth et Série spécifiques doivent être ajoutées à Package.appxmanifest.
• L'interface graphique (double-clic sur le fichier dans l'explorateur de solutions) ne permet pas d'ajouter ces capacités : il faut faire clic droit → Ouvrir avec → Éditeur XML.

Modifiez la section Capabilities (en bas) ainsi :

<Capabilities>
  <Capability Name="internetClient" />
  <DeviceCapability Name="bluetooth.rfcomm">
    <Device Id="any">
      <Function Type="name:serialPort"/>
    </Device>
  </DeviceCapability>
</Capabilities>

La capacité internetClient est déjà présente. Elle n'est pas nécessaire pour cette application, vous pouvez la supprimer. Je la laisse.

Informations sur les appareils appariés

Au démarrage, les appareils appariés sont énumérés :

DeviceInformationCollection DeviceInfoCollection
  = await DeviceInformation.FindAllAsync(RfcommDeviceService.GetDeviceSelector(RfcommServiceId.SerialPort));

Cette collection est transformée en ObservableCollection pour la ListBox :

_pairedDevices = new ObservableCollection<PairedDeviceInfo>();

On itère sur DeviceInfoCollection pour créer un objet PairedDeviceInfo par élément, ajouté à _pairedDevices.

PairedDeviceInfo est une classe avec propriétés :

• Name (string)
• Id (string)
• DeviceInfo (DeviceInformation)

Avec un constructeur approprié. DeviceInformation est Windows.Devices.Enumeration.DeviceInformation.

Dans la liste, le champ Name est affiché (liaison). Quand un appareil est sélectionné (double-clic), son DeviceInformation fait partie de l'élément sélectionné et sert à établir la connexion.

Connexion

Le DeviceInformation permet d'obtenir le service RFCOMM. La connexion s'établit comme un StreamSocket en utilisant le ConnectionHostName (adresse MAC Bluetooth) et le ConnectionServiceName du service :

_service = await RfcommDeviceService.FromIdAsync(DeviceInfo.Id);
_socket = new StreamSocket();
await _socket.ConnectAsync(_service.ConnectionHostName, _service.ConnectionServiceName);

Si tout va bien, le socket est valide (non null). Bien sûr, c'est enveloppé dans un try-catch.

L'envoi et la réception de texte utilisent les propriétés InputStream et OutputStream du socket.

Réception de texte

La réception doit démarrer en premier car elle tourne sur un thread séparé. Elle attend de manière asynchrone l'entrée série, la traite, puis relance une autre réception asynchrone, en boucle jusqu'à annulation :

private async void Listen() {
  ReadCancellationTokenSource = new CancellationTokenSource();
  if (_socket.InputStream != null) {
    dataReaderObject = new DataReader(_socket.InputStream);
    while (true) {
      await ReadAsync(ReadCancellationTokenSource.Token);
    }
  }
}
DataReader dataReaderObject;
private CancellationTokenSource ReadCancellationTokenSource;
private async Task ReadAsync(CancellationToken cancellationToken) {
  uint ReadBufferLength = 1024;
  cancellationToken.ThrowIfCancellationRequested();
  dataReaderObject.InputStreamOptions = InputStreamOptions.Partial;
  var loadAsyncTask = dataReaderObject.LoadAsync(ReadBufferLength).AsTask(cancellationToken);
  UInt32 bytesRead = await loadAsyncTask;
  if (bytesRead > 0) {
    string recvdtxt = dataReaderObject.ReadString(bytesRead);
  }
}

Envoi de texte

La réception est asynchrone (arrivée non déterministe), l'envoi est déclenché par l'UI et est essentiellement synchrone (avec await pour libérer l'UI) :

private async void Send(string msg) {
  Task storeAsyncTask;
  DataWriter dataWriteObject = new DataWriter(_socket.OutputStream);
  dataWriteObject.WriteString(msg);
  storeAsyncTask = dataWriteObject.StoreAsync().AsTask();
  UInt32 bytesWritten = await storeAsyncTask;
}

États des boutons

Les boutons de commande sont activés/désactivés selon l'état de l'application. Par exemple, Send et Start Recv sont désactivés quand l'application n'est pas connectée, activés quand elle l'est, etc.

Amusez-vous bien ! :)