IoT :applications Windows Remote Arduino et Universal

À propos de ce projet

Remarque :consultez les mises à jour dans les commentaires en bas.

Une application Windows 10 UWP peut être construite sur le Câblage à distance bibliothèque de sorte que l'application puisse interagir avec un appareil Arduino exécutant Firmata. Une application, similaire à l'exemple « Blinky » de Windows Remote Arduino, mais avec des ajouts de fonctionnalités, est développée. Il exécute GPIO (sortie ET entrée) ainsi que quelques E/S analogiques. Cette application est fonctionnellement identique à la version Windows 8.1 du blog précédent de cette série. Ce blog fonctionne avec le même matériel (c'est-à-dire en répète une grande partie) que le blog précédent, mais à partir du contexte de la plate-forme Windows universelle (UWP) plutôt que du contexte de l'application universelle Windows 8.1. La cible de l'application est le bureau Win 10, le téléphone Win 10 et Raspberry PI2 (exécutant Win 10 IoT). Ce dernier objectif est un "travail en cours cependant". Ce blog peut être lu sans référence au blog précédent.

Ce projet est détaillé sur mon blog à http://embedded101.com/Blogs/David-Jones/entryid/636/Windows-10-IoT-Windows-Remote-Arduino-and-Universal-Windows-Platform-Apps

L'exemple Windows Remote Arduino « Blinky » est sur ms-iot.github.io.

Applications universelles et applications universelles de la plate-forme Windows

Les applications universelles (UA) ont atteint leur apogée dans Windows 8.1. Vous pouvez implémenter des applications ciblées sur le bureau Windows Intel, l'ARM RT Surface et le Windows Phone (ARM), le tout dans la même solution. Ils pourraient partager un code commun tel que des gestionnaires d'événements, des calculs généraux et des données. Le code XAML devait être spécifique à la cible. Vous venez de compiler les sous-projets séparés pour chaque cible. Lors des compilations, le code commun a été inclus.

Avec le changement de paradigme « One Windows » dans Windows 10, le même code pour toutes les cibles, y compris le code XAML, peut être utilisé pour toutes les cibles. Le même projet doit juste être recompilé pour différentes cibles. Avec le nom UA appliqué aux applications Windows 8, un nouveau nom était nécessaire pour les applications véritablement universelles. C'est pourquoi le nom d'applications de la plate-forme Windows universelle a été inventé pour Windows 10.

Toutes les plates-formes Windows 10 prennent en charge les applications UWP. Mais il existe des extensions spécifiques à chaque plateforme. Par exemple, les extensions Windows 10 IoT prennent en charge GPIO, I2C, SPIO, etc. Les extensions mobiles prennent en charge les fonctions téléphoniques. Etc. UWP fournit une couche API de base garantie sur tous les appareils.

Les SDK d'extension Windows 10. Les extensions Desktop, Mobile et IoT sont vérifiées.

Pour ce blog, nous utilisons le modèle UWP plutôt que l'UA comme dans le blog précédent. Nous n'avons besoin d'aucun des SDK d'extension.

[1] Configurez la communication Bluetooth avec l'appareil Arduino.

Vous pouvez ignorer cette section si vous avez déjà effectué l'activité Win 8.1.

USB ou Bluetooth peut être utilisé pour les communications Firmata entre le périphérique Arduino et le périphérique Windows. Pour Windows 10, les deux peuvent être utilisés, tandis que pour Windows 8.1, seul Bluetooth peut être utilisé. Pour cette version de l'application, Bluetooth sera utilisé. J'ai utilisé un Sparkfun Bluetooth Mate Gold tandis que le Sparkfun Bluetooth Mate Silver a été utilisé avec l'exemple « Blinky » référencé ci-dessus. La principale différence est que la portée de l'or va jusqu'à 100 m alors que celle de l'argent est de 10 m. Les paramètres d'établissement de liaison par défaut sont également différents. Ceux-ci ont tous deux une interface UART de niveau TTL qui peut être utilisée à la fois pour configurer le mode de fonctionnement du périphérique Bluetooth et pour interagir avec le port série Arduino.

Si vous devez configurer l'appareil Bluetooth, un appareil Sparkfun ou Freetronics USB-Serial ou Free peut être utilisé pour configurer l'appareil via un terminal série de bureau. Vous pouvez également réinitialiser l'appareil aux paramètres par défaut en connectant la broche PIO6 (c'est en fait PIO4) à l'état haut et basculer trois fois.

Bluetooth Mate a le même brochage que le Sparkfun FTDI Basic, et ils peuvent donc être utilisés de manière interchangeable. vous ne pouvez pas brancher directement le Bluetooth Mate sur une carte FTDI Basic (vous devrez échanger TX et RX). Cette configuration peut être utilisée avec un terminal série de bureau, avec le périphérique FTDI USB connecté au bureau, pour configurer le périphérique Bluetooth (ou pour utiliser le périphérique Bluetooth pour les communications série depuis le bureau.

Les paramètres série TTL UART par défaut sont :

• · Débit en bauds 115 200
• · 8 bits
• · Pas de parité
• · 1 bit d'arrêt
• · Contrôle du flux matériel activé (sur Mate Silver c'est Aucun)
• · Profil de port série (SPP) :FireFly-WXYZ
  où WXYZ correspond aux 4 derniers chiffres de l'adresse MAC BT de l'appareil.
• · Clé d'accès 1234

Notez que l'appareil peut stocker jusqu'à 8 appariements d'appareils.

La documentation du périphérique Bluetooth se trouve à l'adresse :
http://www.sparkfun.com/datasheets/Wireless/Bluetooth/rn-bluetooth-um.pdf

La configuration Firmata est pour un débit en bauds de 57600 qui doit être modifié ou le périphérique Bluetooth configuré pour cela. Pour cet exercice, nous allons modifier la configuration Firmata, qui est l'approche la plus simple. Le flux de contrôle matériel peut également être géré en configurant le périphérique Bluetooth, mais pour cet exercice, il est géré en connectant RTS à CTS.

Alors que le périphérique Bluetooth peut être monté sur une planche à pain et connecté à l'appareil Arduino à partir de là, j'ai choisi de monter une prise pour celui-ci sur un bouclier de prototypage.

Un en-tête Arduino Shield à 6 broches a été soudé sur le périphérique Bluetooth au niveau des broches TTL UART avec la prise tournée vers l'extérieur. Les broches ont été pliées à 900 vers le bas afin que l'appareil puisse être branché verticalement dans une autre embase de blindage. La prise BT peut ensuite être utilisée pour la connecter directement à un module de base FTDI monté de manière similaire si une configuration est requise. Un fil a ensuite été soudé à PIO6 (PIO4) sur le module Bluetooth, pour une réinitialisation d'usine.

Figure 3 Module Bluetooth avec en-tête de blindage aux broches UART et en-têtes de blindage

Un en-tête de 8 boucliers a été monté au milieu du prototype de bouclier en bas. Ajoutez également des en-têtes à l'extérieur du bouclier afin qu'il puisse se brancher directement sur l'Uno.

Figure 4 Arduino Prototype Shield pour le montage du module Bluetooth

Le module Bluetooth est alors inséré face aux broches GPIO, vers les broches 0 et 1 (Rx/Tx)., laissant l'emplacement jaune libre. L'un d'eux peut être utilisé comme emplacement temporaire pour le fil de réinitialisation d'usine.

Figure 6 Module Bluetooth monté sur un périphérique Arduino

[2] Configurer Firmata

Vous pouvez ignorer cette section si vous avez déjà effectué l'activité Win 8.1.

Remarque : Les broches UART 0 et 1 de l'Arduino Uno ne sont pas disponibles lorsqu'elles sont programmées via USB à partir de l'IDE Arduino. Ces mêmes broches sont connectées à l'interface TTL UART du module Bluetooth lorsqu'il est interfacé pour les communications Firmata. Par conséquent, lorsque le périphérique Arduino doit être programmé dans cette section, le périphérique Bluetooth ne doit pas être connecté.

2.1 En supposant que vous ayez déjà développé un périphérique Arduino (Uno), créez un nouveau shield Firmata standard :

2.2 Il y a un changement à faire, le Baud rate. Dans l'IDE, recherchez 57600. Remplacez-le par 115200. Enregistrez le croquis, je l'ai appelé Firmata_115200. Programmez l'Uno et cette partie est terminée.

[3] Configurer la pile logicielle Universal App Firmata

Cette section n'est que légèrement différente de celle qui a déjà fait l'activité Win 8.1.

La pile logicielle se compose de trois couches :

L'API de câblage à distance implémente des propriétés (configuration), des méthodes et des événements à un niveau conceptuel élevé pour l'interaction matérielle Arduino. Par exemple, GPIO (par exemple, Get and Set Pin, On Pin a changé, etc.). Il communique avec la couche Firmata en utilisant le protocole Firmata. Firmata communique en aval de la pile via le protocole série qui est implémenté en tant que couches de transport Bluetooth et USB-Série dans la couche série. L'option USB n'est pas disponible pour Windows 8.1.

Cette pile logicielle appelée est disponible pour deux sources :

1. https://github.com/ms-iot/windows-remote-arduino-samples
2. https://github.com/ms-iot/remote-wiring/

Les deux contiennent les versions Windows 8.1 et Windows 10. Alors que les versions Windows 10 des deux versions seront construites, j'ai constaté que Windows 8.1 de la seconde ne sera pas construit. J'ai utilisé la version Visual Studio 2015 RC :

• Microsoft Visual Studio Community 2015 RC
• Version 14.0.22823.1 D14REL
• Microsoft .NET Framework
• Version 4.6.00076

3.1 Téléchargez la première version. Pour le faire correctement, vous devez cloner le référentiel (ne téléchargez pas le zip) :

• Installer git ou GitHub
• Dans le shell git ou GitHub Desktop Shell (c'est Powershell), saisissez ce qui suit à partir d'un répertoire approprié :
  

  git clone --recursive https://github.com/ms-iot/windows-remote-arduino-samples.git

  La structure de répertoire de ce que vous obtenez est :

windows-remote-arduino-samples     o le câblage à distance        Microsoft.Maker.win8_1       Microsoft.Maker.win10      source     o win8_1       o win10

Ces deux derniers dossiers (win8_1 et win10) ne sont que des exemples d'applications (y compris l'exemple « blinky ») que nous ignorerons pour le moment. Les deux versions de Maker utilisent le même dossier sources, donc pour Windows 10, nous avons juste besoin de :

windows-remote-arduino-samples      o Câblage à distance        Microsoft.Maker.win10           source

dans un dossier approprié. Je suggère un à la racine du lecteur, disons, c:\wras10 car j'ai constaté que vous pouvez obtenir des erreurs avec une version ARM à cause des noms de chemin trop longs. Vous pouvez également copier les fichiers .md pour référence. Ceux-ci peuvent être ouverts dans VS.

3.2 Ouvrir le fichier solution dans Microsoft.Maker.win10

3.3 Définissez la cible sur Win32 pour créer la solution.

Trois constructions sont terminées. Un pour chacune des trois couches de la pile logicielle.

3.4 Faites de même pour la configuration ARM. Si vous avez une machine x64, vous pouvez également essayer cette version.

[4] Créer l'application HW LED UWP

Il y a un "court-circuit" dans cette section pour ceux qui ont fait l'activité précédente Win 8.1.

Pour cette version initiale de l'application ou des applications, un bouton logiciel allumera un voyant matériel et un autre l'éteindra. La LED sera connectée à la broche GPIO 5.

La documentation « Blinky » indique qu'il existe un certain nombre de façons d'obtenir et d'utiliser ces bibliothèques. En fin de compte, Nuget sera le moyen mais ce n'est pas encore disponible. Vous pouvez référencer ces versions construites de manière générale sur votre système de développement. Le moyen le plus simple consiste simplement à ajouter l'application universelle requise à la solution et à les référencer. Nous utiliserons cette méthode.

4.1 Ajoutez une nouvelle application Windows Blank Universal C# à la solution. (Notez pas Windows 8.1 cette fois) :

Donnez-lui un nom approprié. J'ai appelé le mien wrauwp:Application Windows Remote Arduino Universal UWP.
Notez que cette fois, il n'y a qu'UN seul projet créé (UWP). Le code XAML et CSharp est le même pour les versions de bureau et mobile de l'application. La différence réside dans la façon dont il est compilé.

Les capacités série et Bluetooth sont nécessaires dans le manifeste du package :

4.2 Ouvrez le package.appmanifest dans l'éditeur de texte (pas son interface graphique) par View Code. La capacité du client Internet est incluse en bas. Modifiez cette section pour :

Dans packkage.appmanifest

De plus, si nous utilisions USB-Serial plutôt que Bluetooth-Serial sur le bureau, nous ajouterions une capacité pour cela.

Une référence à chacune des couches logicielles pertinentes est requise :

4.3 Ajouter des références Firmata, RemoteWiring et Serial pour l'UA de bureau (encore une fois, vous n'avez besoin de le faire que pour un projet) :

CONSEIL :Pour ceux qui ont déjà fait le précédent Windows 8.1, vous pouvez maintenant court-circuiter ce qui suit  :

• Copiez le code XML de la grille de ce projet vers MainPage.xaml dans ce nouveau projet.
• Vous pouvez maintenant passer au test de l'application sur la ou les cibles

Pour ceux qui continuent ici…

4.4 Modifier les deux Grid XAML d'UA en :

MainPage.xaml :interface utilisateur
                              Off !     Activé !

Commentaire Nous n'avons qu'une seule MainPage.cs cette fois, car il n'y a qu'un seul projet d'application… One Windows.
Auparavant, il y en avait un pour le bureau et un pour le téléphone, que nous avons rendus communs en plaçant une version dans le sous-projet de partage.

Tout le code cs fera référence à MainPage.cs

4.7 Dans la classe MainPage, ajoutez les déclarations suivantes en haut de la classe :

Déclarations MainPage.cs

//Usb n'est pas pris en charge sur Win8.1. Pour voir les étapes de connexion USB, référez-vous plutôt à la solution win10. BluetoothSerial bluetooth ; RemoteDevice arduino ;   // Les broches utilisées. Remarque : numéros de pinn réels. private const int LED_PIN =5 ;

4.8 dans le constructeur MainPage, après InitializeComponent() ajouter :

Dans MainPage() le constructeur

bluetooth =new BluetoothSerial("FireFly-748B"); arduino =new RemoteDevice(bluetooth); bluetooth.ConnectionEstablished +=OnConnectionEstablished ;

Remplacez FireFly-748B par votre SPP.

4.9 Implémentez OnConnectionEstablished en ajoutant la méthode suivante à la classe :

Ajouter OnConnectionEstablished()

private void OnConnectionEstablished() {     //activez les boutons sur le fil d'interface utilisateur !     var action =Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, nouveau Windows.UI.Core.DispatchedHandler(() => {         this.OnButton.IsEnabled =true ;         ceci. OffButton.IsEnabled =true ;           arduino.pinMode(LED_PIN, PinMode.OUTPUT);     })); }

4.10 Et enfin, ajoutez les gestionnaires d'événements pour les boutons à la classe :

Ajouter des gestionnaires d'événements de bouton

private void OnButton_Click(objet expéditeur, RoutedEventArgs e) {     //allumer la LED connectée à la broche 5     arduino.digitalWrite(5, PinState.HIGH); }   private void OffButton_Click(objet expéditeur, RoutedEventArgs e) {     //éteindre la LED connectée à la broche 5 sur OFF     arduino.digitalWrite(5, PinState.LOW); }

4.11 Tester la construction de l'application UWP dans les configurations x86, x64 et ARM

[5] Déploiement et test des applications universelles.

Dans cette section, nous allons connecter la LED matérielle à l'appareil Arduino et exécuter l'application sur le bureau, ainsi qu'un Windows 10 Phone*

Testez sur votre bureau

5.1 Définir l'application de bureau comme projet de démarrage

5.2 Définissez la cible sur x86 et Machine locale. Reconstruire l'application UWP de bureau

5.3 Connectez l'Arduino Pin 5 à une LED matérielle. Fournir GND, VCC et une résistance appropriée en série.

Comme mentionné dans un blog précédent concernant Windows 10 IoT Raspberry PI 2 GPIO J'utilise une carte de développement pour implémenter mes E/S de test telles que des LED, des commutateurs, etc. Si vous n'avez pas de carte similaire, vous pouvez utiliser le Configuration matérielle « Blinky » mais vous devrez inverser la polarité du réglage des broches dans les gestionnaires de boutons.

5.4 Allumez l'appareil Arduino et associez le module Bluetooth à votre bureau (Passkey=1234). .. Je suppose que vous savez comment faire.

5.5. Exécutez l'application.

5.6 Il vous demandera probablement si l'application peut se connecter à l'appareil Bluetooth .. OK

5.7 Testez la fonctionnalité de l'application. Définissez un point d'arrêt dans le(s) gestionnaire(s) de bouton et vérifiez que vous pouvez déboguer.

5.8 Répétez 4.1 à 4.6 pour x64 si vous avez un ordinateur de bureau 64 bits.

5.9 Désactiver Bluetooth sur votre bureau

Maintenant, testez votre téléphone Windows 10, en supposant que le téléphone est configuré pour le développement.

5.10 Allumez votre téléphone, allez dans Paramètres/Bluetooth et allumez-le. Associez-le avec le module Bluetooth (Passkey =1234).

5.11 Continuer avec l'application Windows Universal comme projet de démarrage ..

5.12 Définir la cible sur ARM,, Device et reconstruire

5.11 Connectez le téléphone via USB Serial au bureau et déployez l'application.

Maintenant, testons le Raspberry PI 2

C'EST UN TRAVAIL EN COURS. VOIR LA REMARQUE À LA FIN DE CETTE SECTION

5.13 Le débogueur distant est déjà installé et actif sur le RPI2 configuré pour Win 10 IoT.

5.14 Déterminer l'adresse IP du RPI2, par exemple avec Windows IoT Core Watcher

5.15 Dans Project Properties-Debug, définissez la cible sur Remote Machine, No authentication et saisissez l'adresse IP

5.16 Reconstruire l'application UWP

5.17 Déployer et tester l'application sur le RPI2.

Je n'ai pas encore la version RPI2 pour me connecter via Bluetooth :

• Bluetooth dans le principal n'est pas encore pris en charge
• Veuillez laisser des commentaires si vous avez des idées ou un succès avec cela.
• Je mettrai à jour ici lorsque j'aurai progressé

Le dongle Bluetooth est chargé sur le RPI2

[6] "Agréable" l'interface utilisateur

Ce qui suit améliorera l'interface utilisateur et ajoutera des boutons de connexion et de déconnexion Bluetooth.

6.1 Modifiez le code UI GRID XAML en (PS : notez la modification des lignes de grille de boutons précédentes ):

Ajouter deux boutons &

                                                             

Connect     Off !     Activé !     Déconnecter    

L'interface utilisateur a des boutons plus gros et est plus colorée, offrant une meilleure convivialité. J'y suis arrivé après avoir été testé par un utilisateur avec ma petite-fille de 4 ans !

Le anneau de progression est visible et circule pendant la connexion de l'application.

6.2 Insérer en bas de OnConnectionEstablished() :

Dans OnConnectionEstablished()

//BT est connecté donc désactivez la sonnerie de progression this.progress1.IsActive =false ; this.progress1.Visibility =Visibility.Collapsed ;

6.3 Ajoutez les gestionnaires suivants pour les boutons Connecter et Déconnecter :

Ajouter de nouveaux gestionnaires d'événements de bouton

private void ConnectButton_Click(objet expéditeur, RoutedEventArgs e) {     //ces paramètres n'ont pas d'importance pour Bluetooth-Arduino Firmata, sauf SerialConfig.SERIAL_8N1     bluetooth.begin(115200, SerialConfig.SERIAL_8N1) ;     this.ConnectButton.IsEnabled =false ;       //Connecter BT pour afficher l'anneau de progression     this.progress1.IsActive =true ;     this.progress1.Visibility =Visibility.Visible ; }   private void DisconnectButton_Click(objet expéditeur, RoutedEventArgs e) {     bluetooth.end();     this.OnButton.IsEnabled =false ;     this.OffButton.IsEnabled =false ;     this.ConnectButton.IsEnabled =true ;     this.DisconnectButton.IsEnabled =false ; }

6.4 Commentez ou supprimez la ligne suivante de MainPageConstructor car elle se trouve maintenant dans le gestionnaire de bouton Connect :

bluetooth.begin(115200, SerialConfig.SERIAL_8N1) ;

6.5 Ajouter la gestion d'état suivante au gestionnaire OnButton

Dans OnButton_Cllick()

this.OffButton.IsEnabled =true ; this.OnButton.IsEnabled =false ;

6.6 Et ce qui suit au gestionnaire OffButton :

Dans OffButton_Click

this.OffButton.IsEnabled =false ; this.OnButton.IsEnabled =true ;

6.7 Déployer et tester l'application sur les trois (4) cibles comme dans la section 5

[7] Ajouter une entrée Bouton poussoir

Dans cette extension des applications universelles Windows 8.1, une entrée GPIO à bouton-poussoir, au niveau de la broche Arduino 5, est facilitée et son état est affiché dans l'interface utilisateur. L'entrée sera initialement détectée en lisant périodiquement la valeur.

La fonctionnalité sera ensuite améliorée en implémentant un gestionnaire pour l'événement DigitalPinChanged

7.1 Modifiez le contrôle Grid dans le code XAML de l'interface utilisateur pour les deux UA comme suit :

Ajouter une zone de texte à l'interface utilisateur

                                                                     

Connect     Off !     Activé !     Déconnecter        

7.2 Dans la classe MainPage, spécifiez la broche d'entrée :

- Dans les déclarations en haut de la classe, ajoutez la broche d'entrée :

Dans les déclarations MainPage

private const int PB_PIN =6 ;

- Dans le gestionnaire OnConnectionEstablished, définissez-le sur input :

Dans OnConnectionEstablished

arduino.pinMode(PB_PIN, PinMode.INPUT);

7.3, Ajoutez une minuterie pour interroger l'entrée comme suit :

- Dans les déclarations en tête de classe :

Dans les déclarations MainPage

// En mode sondage, les coches de la minuterie échantillonnent les entrées dispatcherTimer privé pbPolltimer ;

- Dans le constructeur réglez le timer :

Dans MainPage()

this.pbPolltimer =new DispatcherTimer(); this.pbPolltimer.Interval =TimeSpan.FromMilliseconds(250); this.pbPolltimer.Tick +=PBTimer_Tick ; this.pbPolltimer.Stop();

- Ajouter son gestionnaire d'événements de tick de minuterie

Ajouter un gestionnaire de ticks de minuterie de sondage

PinState pbPinValue =PinState.LOW ;   private void PBTimer_Tick(objet expéditeur, objet e) {     PinState pbPinValueTemp =arduino.digitalRead(6) ;     Pushbutton_Pressed(pbPinValueTemp); }

- Implémenter PushButton_Pressed() :

Ajouter PushButton_Pressed()

private void Pushbutton_Pressed(PinState pbPinValueTemp) {     if (pbPinValue !=pbPinValueTemp)     {         //Écrire la valeur si elle est modifiée         TxtPin6.Text ="Bouton :" + pbPinValueTemp.ToString();         pbPinValue =pbPinValueTemp ;     } }

7.4 Nous avons besoin d'un interrupteur à bouton-poussoir. Heureusement, ma carte de développement les fournit, donc je les utilise simplement. Si vous n'avez pas une telle bête, alors implémentez le circuit ci-contre.

Dans cette extension des applications universelles Windows 8.1, une entrée GPIO à bouton-poussoir, au niveau de la broche Arduino 5, est facilitée et son état est affiché dans l'interface utilisateur. L'entrée sera initialement détectée en lisant périodiquement la valeur. Avec le Win 10 IoT Raspberry PI 2 (RPI2), il a été signalé  qu'il y a quelques bugs avec la fréquence d'enregistrement des entrées numériques, qui seront corrigés dans le RTM pour Win 10 IoT.

La fonctionnalité sera ensuite améliorée en implémentant un gestionnaire pour l'événement DigitalPinChanged

L'anti-rebond peut être amélioré pour cette situation dans le matériel en :

- Mettez un petit condensateur sur le commutateur pour ajouter du matériel anti-rebond comme retard RC.

- Ajoutez également un déclencheur Schmidt à ce circuit.

Avec le RPI2, il existe une option pour ajouter un anti-rebond via la configuration logicielle.

Avec le RPI2, il existe une option pour ajouter un anti-rebond via la configuration logicielle.

7.5 Construire, déployer et tester l'application sur les cibles comme précédemment

Ajoutons une LED simulée par logiciel à l'interface utilisateur pour afficher l'état du commutateur.

7.6 Ajoutez les éléments suivants à l'interface utilisateur dans le code XAML de la grille dans les deux applications universelles :

- Ajoutez une autre définition de ligne (en bas) : :            

- Ajoutez le contrôle ellipse suivant à cette ligne :

Ajouter une ellipse à l'interface utilisateur

7.7 Ajoutez deux définitions de pinceaux de couleur aux déclarations de classe MainPage en haut :

Ajouter des couleurs dans les déclarations

// Couleurs pour l'ellipse lorsque le bouton-poussoir matériel est enfoncé/non enfoncé privé SolidColorBrush redBrush =new SolidColorBrush(Windows.UI.Colors.Red); private SolidColorBrush grayBrush =new SolidColorBrush(Windows.UI.Colors.LightGray);

7.8 Implémentez la manipulation des LED avec ces couleurs comme suit :

- Dans le constructeur de classe, définissez sa couleur initiale :

Dans le constructeur

//Commencer par la couleur désactivée pour l'ellipse this.PBStatusLED.Fill =grayBrush ;

- Dans PushButtonPressed(), définissez sa couleur en fonction de l'état du bouton :

Ajouter à Pushbutton_Pressed()

commutateur (pbPinValue) {     case PinState.HIGH :         this.PBStatusLED.Fill =redBrush ;         pause ;     cas PinState.LOW :         this.PBStatusLED.Fill =grayBrush;         pause ; }

7.9 Construire, déployer et tester les applications sur les cibles ..Wala!

Maintenant, améliorez ce code à l'aide de l'événement numérique.

7.10 Mettez en commentaire tout le code lié à la minuterie, mais laissez la fonction PushButtonPressed(); d'où la raison de la séparation du gestionnaire d'événements timer tick.

7.11 Ajouter la spécification de délégué d'événement au gestionnaire d'événement OnConnectionEstablished() dans l'action

Ajouter à OnConnectionEstablished

arduino.AnalogPinUpdatedEvent +=Arduino_AnalogPinUpdated ;

We could try to implement the event handler as follows:

Invalid DigitalPinUpdated

private async void Arduino_DigitalPinUpdated(byte pin, PinState pinValue) {     if (pin ==PB_PIN)     {         Pushbutton_Pressed(pinValue);     } }

But this fail as the event runs in a thread separate to the main UI thread. This is the same issue as in .NET Windows Forms if (InvokeRequired) scenario.

7.12 Implement the event handler as follows

Add DigitalPinUpdated

private async void Arduino_DigitalPinUpdated(byte pin, PinState pinValue) {       await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>     {         if (pin ==PB_PIN)         {             Pushbutton_Pressed(pinValue);         }       }); }

7.13 Build, deploy and test the apps on the targets. Wala

[8] Add an Analog Input

This extension to the app functionality adds a progress bar to the UA UI to display the level of a potentiometer in the hardware.

The analog input is via A0, pin 14.

Again my development board provides a potentiometer for this purpose but if you don’t have such you need to implement this circuit:

The analog input pins are pins 14 (A0) to pin 19 (A5).

arduino.pinMode(ANALOG_PIN, PinMode.ANALOG);

The comment above is quite pertinent. The event handler signature provides the analog pin index (0 to 5) not the pin number.

Analog values range from 0 to 1024. (10 bit)

// Note:Need actual pin number, not analog index:

arduino.pinMode(ANALOG_PIN, PinMode.ANALOG);

8.0 Re-enable the Poll timer and disable the Pushbutton event in the MainPage class

8.1 In the grid control in the UI XAML code add another row to the grid as previous and add a ProgressBar:

Add a ProgressBar to the UI

8.2 Add the Analog pin code as follows.

- Declare the pin at the top of MainPage class:

Add the Analog Pin

private const int ANALOG_PIN =14;

- Set its mode to analog in OnConnectionEstablished() as above

- Add the following to the timer tick event:

Add to Timer Tick Handler

//Note:Analog Read Pin number is the analog index int PinValue =arduino.analogRead(ANALOG_PIN-14); this.analogBar.Value =PinValue;

8.3 Build, deploy and test the app on the targets. Vary the potentiometer position and observe the ProgressBar changes.

Now for the event driven version

8.4 Again comment out the Poll Timer code.

8.5 Add the analog event handler delegate specification to OnConnectionEstablished():

Set Analog Pin Mode

// Note:Need actual pin number, not analog ibndex: arduino.pinMode(ANALOG_PIN, PinMode.ANALOG);

8.6 Add the Arduino_DigitalPinUpdated event handler method:

Add AnalogPinUpdated

private async void Arduino_AnalogPinUpdated(byte pin, ushort PinValue) {     //Note:Pin number is the analog index     if (pin ==ANALOG_PIN -14)     {         await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>         {             this.analogBar.Value =PinValue;         });     } }

Note that the UI update has again to be done asynchronously.

8.7  Build, deploy and test the app on the targets.

[9] Add a PWM output

It is left to reader to implement analog output as PWM, to drive a LED (dimmed via a slider).

• PWM pins:
  3, 5, 6, 9, 10, and 11>
• To set a pin as PWM:
  arduino.pinMode(PWM_PIN,PinMode.PWM)>
• To set a PWM level
  arduino.analogWrite(byte, ushort)>
• analogWrite values are from 0 to 255 (the ushort parameter)

I might provide a solution to this at a later stage.

[1] I actually used a retired earlier version of the Bluetooth module, but functionality seems to be the same.

Code

• WindowsRemoteArduino_Win10.zip

WindowsRemoteArduino_Win10.zipC#

No preview (download only).

Schémas