Bluetooth série générique avec Win 10 IoT-Core RPI2

Applications et services en ligne

	Microsoft Windows 10 IoT Core
	Microsoft Visual Studio 2015

À propos de ce projet

Plus loin

Ce projet est décrit en détail sur embedded101.com :

« Win 10 IoT-Core :application série Windows universelle Bluetooth »

À propos

Ce projet est une application Windows universelle qui connecte un appareil IoT-Core tel qu'un Raspberry PI 2 à un appareil Bluetooth intégré via le profil série Bluetooth à l'aide d'un dongle USB Bluetooth génétique.

Contexte

.Bluetooth prend en charge les réseaux peer to peer sur une courte portée. Contrairement à un réseau Wi-Fi, la connectivité Bluetooth est un à un. Deux appareils peuvent se connecter et interagir. Par exemple, deux appareils peuvent se connecter de manière symétrique en utilisant le profil série et passer des données brutes entre eux. En général, cependant, la connectivité Bluetooth est asymétrique, une extrémité générant un format de données spécifique à consommer à l'autre extrémité. Par exemple, un téléphone mobile peut implémenter le profil A2DP (Advanced Audio Distribution Profile) et diffuser de l'audio vers un casque qui implémente le profil HSP (Headset) OBEX (Object Exchange) est une connexion symétrique entre deux appareils lorsqu'ils échangent des données entre eux.

Le projet Microsoft IOT-Core Bluetooth Sample utilise le GATT (Generic Attribute Profile Profile). Cela fournit des services de découverte et de description de profil pour le protocole Bluetooth Low Energy. Avec ce protocole, des appareils simples à faible consommation peuvent être connectés à une extrémité, générant des données qui seront consommées par un processeur complexe.

Il s'agit d'un projet bien plus simple que l'exemple Microsoft. Il ne concerne que le SPP (Serial Port Profile) plus générique qui est basé sur le profil RFCOMM. Il a été développé avec une très ancienne clé USB Bluetooth et devrait donc fonctionner avec n'importe quelle clé Bluetooth.

L'application IoT

Cette application est une simple application de test Bluetooth Serial Universal Windows (Windows 10). Il commence par énumérer (sous forme de liste) tous les appareils associés par Bluetooth à l'appareil sur lequel l'application est en cours d'exécution. L'un est sélectionné par double-clic qui initie la connexion. Le texte à envoyer est saisi dans une zone de texte et envoyé lorsqu'un bouton est enfoncé. L'application reçoit automatiquement tout texte qui lui est envoyé (et l'affiche). Par conséquent, lorsque le point de terminaison (comme ci-dessus) renvoie simplement le texte qu'il a reçu, le texte envoyé doit réapparaître dans la zone de réception de l'application UW.

Le point final

Pour tester un Arduino Uno avec un adaptateur Bluetooth est utilisé. Il a un simple bouclier qui renvoie simplement tous les caractères qu'il reçoit via la connexion Bluetooth :

La configuration du bouclier :

// Une application de bouclage série// Configuration antérieure// Initié par le système connecté// Remarque peut être utilisé avec Bluetooth où les RxTx du périphérique BT// sont connectés au TxRx de la carte Arduino. // Besoin de déconnecter l'adaptateur BT pour la programmation. void setup() { // Mon adaptateur est défini sur ce BAUD 115200 // Il s'agit du débit de port de l'adaptateur Arduino vers BT // Défini lorsque l'adaptateur BT est en mode commande. // Ce n'est PAS le taux BT que vous ne pouvez pas définir. Serial.begin(115200); retard (333); tandis que (!Série); retard(1000); Serial.println("Le renard brun rapide saute par-dessus le chien paresseux !");} 

La boucle de bouclier :

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

Couplage

Bluetooth est un scénario peer to peer. Avant de pouvoir se connecter via Bluetooth, ils doivent être couplés. Cela ne se fait pas dans l'application. Le jumelage avec un mot de passe peut être problématique entre les appareils intégrés car ils sont souvent sans tête et peuvent ne pas prendre en charge les fenêtres contextuelles (comme IoT-Core ne le fait pas). Il existe un portail Web IoT-Core pour ce faire, ainsi qu'un utilitaire de ligne de commande sur l'appareil qui peut être exécuté sur un shell SSH. La version la plus récente du portail Web du système d'exploitation prend en charge l'association de clés de passe qui manquait à l'époque de Windows 10 RTM. "Win 10 IoT-Core:Bluetooth Universal Windows Serial App" traite en détail de l'appairage dans ce contexte.

Démarrage du projet

Le projet d'application est créé dans Visual Studio 2015 à l'aide du modèle d'application Windows universel :

Nouveau projet-->Visual C#->Windows->Application vierge (Windows universel)

Création de l'interface utilisateur de l'application

L'interface utilisateur est implémentée en XAML

Créez l'interface utilisateur selon la mise en page ci-dessus (ou similaire) :

L'interface utilisateur est assez simple et est créée comme suit :

• Tous les éléments de texte sont des TextBlocks sauf le SendText qui est une TextBox
• SendText accepte CarriageReturn (c'est-à-dire multiligne)
• Le texte Recvd a le WrapText activé (c'est-à-dire qu'il est multiligne)
• Les éléments de l'interface utilisateur sont organisés en lignes à l'aide d'un StackPanel défini sur une orientation horizontale
• Ces StackPanels sont ensuite empilés avec un StackPanel réglé à l'orientation verticale, ainsi que la ListBox.

Vous préférerez peut-être mettre en page l'interface utilisateur à l'aide de StackPanels relatifs ou utiliser des lignes et des colonnes de grille, etc.

Le ConnectDevices est une ListBox avec une source de liaison définie sur PairedDevices (voir plus tard ) et un ItemTemplate constitué d'un TextBlock lié à la propriété Name de PairedDevices (voir plus loin ).

Configuration de l'application

• L'application n'utilise pas les fonctionnalités IOT-Core et ne nécessitera donc aucune référence d'extension.
• L'application aura besoin de fonctionnalités spécifiques pour Bluetooth et série ajoutées à Package.appxmanifest.
• Malheureusement, l'interface utilisateur que vous obtenez pour cela si vous double-cliquez sur ce fichier dans l'Explorateur de solutions ne prend pas en charge l'ajout de ces fonctionnalités et vous devez donc les ajouter manuellement en cliquant avec le bouton droit sur le fichier dans l'Explorateur de solutions et sélectionnez Ouvrir avec->Éditeur XML.

Modifiez la section des capacités (en bas) pour :

La capacité internetClient sera déjà là. Ce n'est pas nécessaire pour cette application, vous pouvez donc la supprimer. Je le laisse.

Informations sur les appareils jumelés

Au démarrage de l'application, les appareils couplés sont énumérés à l'aide de :

DeviceInformationCollection DeviceInfoCollection

=wait DeviceInformation.FindAllAsync(RfcommDeviceService.GetDeviceSelector(RfcommServiceId.SerialPort));

Cette collection est ensuite transformée en une ObservableCollection qu'il peut être utilisé dans la ListBox :

_pairedDevices =new ObservableCollection();

La DeviceInfoCollection est itéré en créant un PairedDeviceInfo objet pour chaque élément qui est ensuite ajouté aux _pairedDevices collection.

Informations sur les appareils appariés est une classe avec des propriétés :

Nom

Id

DeviceInfo

La classe a un constructeur approprié.

Informations sur l'appareil est Windows.Devices.Enumeration.DeviceInformation

Dans la liste des appareils couplés, le Nom le champ est (lié) affiché.

Lorsqu'un appareil est sélectionné (double-clic), les informations sur l'appareil du point de terminaison font en fait partie de l'élément de menu sélectionné et sont donc utilisées pour établir la connexion.

Connexion

DeviceInformation est utilisé pour obtenir le service RFCOMM. La connexion est ensuite établie en tant que StreamSocket en utilisant le Endpoint HostName (en fait son adresse Bluetooth Mac) et la chaîne ServiceName.

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

Si tout va bien alors nous avons une connexion .. le socket sera significatif (non nul).

Bien sûr, il s'agit d'une erreur piégée (try-catch)

Envoyer du texte et Recevoir du texte utilisent les propriétés InputStream et OutputStream du socket.

Recevoir du texte

La réception de texte doit être démarrée en premier car elle s'exécute en tant que fil distinct. Il exécute une attente asynchrone pour obtenir une entrée série, gère l'entrée puis exécute une autre réception série asynchrone .. le tout en boucle. Cette boucle continue jusqu'à ce qu'une annulation soit générée.

private async void Listen(){ ReadCancellationTokenSource =new CancellationTokenSource(); if (_socket.InputStream !=null) { dataReaderObject =new DataReader(_socket.InputStream); // continue à lire l'entrée série while (true) { wait ReadAsync(ReadCancellationTokenSource.Token); } }}DataReader dataReaderObject;private CancellationTokenSource ReadCancellationTokenSource;private async Task ReadAsync(CancellationToken cancelToken){ uint ReadBufferLength =1024; // Si l'annulation de la tâche a été demandée, respectez cancelToken.ThrowIfCancellationRequested(); // Définissez InputStreamOptions pour terminer l'opération de lecture asynchrone lorsqu'un ou plusieurs octets sont disponibles dataReaderObject.InputStreamOptions =InputStreamOptions.Partial; // Crée un objet de tâche pour attendre les données sur le serialPort.InputStream loadAsyncTask =dataReaderObject.LoadAsync(ReadBufferLength).AsTask(cancellationToken); // Lancer la tâche et attendre UInt32 bytesRead =wait loadAsyncTask; if (bytesRead> 0) { string recvdtxt =dataReaderObject.ReadString(bytesRead); }} 

Envoyer du texte

Alors que le texte reçu est exécuté de manière asynchrone, car l'arrivée du texte n'est pas déterministe du point de vue de l'application, le texte envoyé est traité à partir de l'interface utilisateur de l'application et est donc essentiellement synchrone (bien qu'une attente soit utilisée pour libérer l'interface utilisateur).

private async void Send(string msg){ Task storeAsyncTask; DataWriter dataWriteObject =new DataWriter(_socket.OutputStream); dataWriteObject.WriteString(msg); // Lancer une tâche asynchrone pour terminer l'opération d'écriture storeAsyncTask =dataWriteObject.StoreAsync().AsTask(); UInt32 bytesWritten =wait storeAsyncTask;} 

États des boutons

Les boutons de commande sont activés et désactivés en fonction de l'état de l'application. Par exemple, les boutons Envoyer et Démarrer Recv sont désactivés lorsque l'application n'est pas connectée, mais deviennent activés lorsque l'application est connectée, etc.

Profitez! :)

Code

iotbluetoothserial sur Github