Project tutorial
IoT: Windows Remote Arduino and Universal Apps

IoT: Windows Remote Arduino and Universal Apps © CC BY

A detailed tutorial on doing Windows Remote Arduino. It does "Blinky", an external pushbutton (polled & with an event) as & an analog input

  • 17,823 views
  • 12 comments
  • 44 respects

Components and supplies

About this project

Note: See the updates in the comments at the bottom.

A Windows 10 UWP app can be built upon the Remote-Wiring library such that the app can interact with an Arduino device running Firmata. An app, similar to the Windows Remote Arduino “Blinky” example, but with feature additions, is developed. It performs GPIO (output AND input) as well as some analog IO. This app is functionally the same as Windows 8.1 version in the previous blog in this series. This blog works through the same material (ie repeats much of it) as the previous blog but from the Universal Windows Platform (UWP) context rather Windows 8.1 Universal App context. The target for the app is Win 10 desktop, Win 10 phone and Raspberry PI2 (running Win 10 IoT). The latter target is a "work-in-progress though".This blog can be read without reference to the previous blog.

This project is detailed on my blog at http://embedded101.com/Blogs/David-Jones/entryid/636/Windows-10-IoT-Windows-Remote-Arduino-and-Universal-Windows-Platform-Apps

The Windows Remote Arduino “Blinky” example is at ms-iot.github.io.


Universal Apps and Universal Windows Platform Apps

Universal apps (UA) reached their zenith in Windows 8.1 You could implement apps targeted at Windows Intel desktop, the ARM RT Surface and the Windows Phone (ARM), all in the same solution. They could share common code such as event handlers, general computation and data. XAML code had to be specific to the target. You just compiled the separate subprojects for each target. During the compilations, the common code was included.

With the “One Windows” paradigm shift in Windows 10 the same code for all targets, including the XAML code can be used for all targets. The same project just needs to be recompiled for different targets. With the UA name applied to Windows 8 apps, a new name was needed for the truly universal apps. Hence the name Universal Windows Platform apps was coined for Windows 10.

All Windows 10 platforms support UWP apps. But there are extensions specific to the each platform. For example Windows 10 IoT extensions support GPIO, I2C, SPIO etc. Mobile extensions support phone functions. Etc. UWP provides a guaranteed core API layer across all devices.


The Windows 10 Extension SDKs. The Desktop, Mobile and IoT extensions are checked.

For tis blog we use the UWP template rather than the UA as in the previous blog. We don't need any of the extension SDKs.


[1] Set up the Bluetooth communication with the Arduino device.

You can skip this section if you have already done the Win 8.1 activity.

USB or Bluetooth can be used for the Firmata communications between the Arduino device and the Windows device. For Windows 10 both can be used, whereas for Windows 8.1 only Bluetooth can be used. For this version of the app, Bluetooth will be used. I used a Sparkfun Bluetooth Mate Gold whereas the Sparkfun Bluetooth Mate Silver was used with the “Blinky” example referenced above. The main difference is the range of the Gold is up to 100m whereas that of the Silver is 10m. The default handshaking settings are also different. These both have a TTL level UART interface that can be used both for configuring the operating mode of the Bluetooth device and for interacting with the Arduino serial port.

If you need to configure the Bluetooth device, a Sparkfun or Freetronics USB-Serial or Free device can be used to configure the device via a desktop serial terminal. You can also factory reset the device to default settings by connecting the PIO6 (its actually PIO4) pin to high, and toggle three times.

Bluetooth Mate has the same pin out as the Sparkfun FTDI Basic, and so they can be used interchangeably. you cannot directly plug the Bluetooth Mate to an FTDI Basic board (you’ll have to swap TX and RX). That configuration can be used with a desktop serial terminal, with the FTDI device USB connected to the desktop, to configure the Bluetooth device (or to use Bluetooth device for serial communications from the desktop.

The default TTL UART serial settings are:

  • · Baud rate 115,200
  • · 8 bits
  • · No Parity
  • · 1 stop bit
  • · Hardware flow control enabled (on Mate Silver this is None)
  • · Serial Port Profile (SPP): FireFly-WXYZ
    where WXYZ is the last 4 digits of the device's BT MAC Address.
  • · Passkey 1234

Note that the device can store up to 8 device parings.

The documentation for the Bluetooth device is at:
http://www.sparkfun.com/datasheets/Wireless/Bluetooth/rn-bluetooth-um.pdf

The Firmata configuration is for a Baud rate of 57600 which needs to be changed or the Bluetooth device configured for that. For this exercise, we will modify the Firmata configuration, which is the easier approach. The Hardware flow of control also can be handled by configuring the Bluetooth device, but for this exercise is handled by connecting RTS to CTS.

Whist the Bluetooth device can be mounted on a Breadboard and connected to the Arduino device from there, I elected to mount a socket for it on a Prototyping Shield.

A 6 pin Arduino Shield Header was soldered onto the Bluetooth device at the TTL UART pins with the socket facing outwards. The pins were bent 900 downwards so that the device can be plugged vertically into another shield header. The BT socket then can be used to directly connect it to similarly mounted FTDI Basic module if configuration is required. A wire was later soldered to PIO6 (PIO4) on the Bluetooth module, for factory resetting.

Figure 3 Bluetooth Module with shield header at UART pins, and shield headers

An 8 shield header was mounted in the middle of the prototype shield at the bottom. Also add headers at the outside of the shield so that it can plug directly into the Uno.

Figure 4 Arduino Prototype Shield for mounting the Bluetooth module

The Bluetooth module is then inserted facing the GPIO pins, towards the pins 0 and 1 (Rx/Tx)., leaving the yellow location clear. One of those can be used a temporary location for the factory reset wire.

Figure 6 Mounted Bluetooth module on Arduino device


[2] Set up Firmata

You can skip this section if you have already done the Win 8.1 activity.

Note: The Arduino Uno’s UART Pins 0 and 1 are unavailable when it is being programmed via USB from the Arduino IDE. These same pins are what are connected to the Bluetooth module’s TTL UART interface when it is interfaced for Firmata communications. Therefore, when the Arduino device is to be programmed in this section, the Bluetooth device should not be connected.

2.1 Assuming that you have previously developed for an Arduino (Uno) device, create a new Standard Firmata shield:

2.2 There is one change to be made, the Baud rate. In the IDE, do a search for 57600. Replace it 115200. Save the Sketch, I called it Firmata_115200. Program the Uno and this part is done.


[3] Set up the Universal App Firmata software stack

This section only slightly different that already done the Win 8.1 activity.

The software stack consists of three layers:

The Remote-Wiring API implements properties (configuration), methods and event at a conceptually high level for Arduino hardware interaction. For example, GPIO (eg Get and Set Pin, On Pin changed etc). It communicates with the Firmata layer using the Firmata protocol. Firmata communicates down the stack via the serial protocol that is implemented as Bluetooth and USB-Serial transport layers in the Serial layer. The USB option isn’t available for Windows 8.1.

This software stack called is available for two sources:

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

Both contain Windows 8.1 and Windows 10 versions. Whilst both versions’ Windows 10 versions will build, I have found that the second one’s Windows 8.1 won’t build. I used the Visual Studio 2015 RC version:

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

3.1 Download the first version. To do so properly, you need to clone the repository (don’t download the zip):

  • Install git or GitHub
  • In the git shell or GitHub Desktop Shell (it’s Powershell), enter the following from a suitable directory:
    git clone --recursive https://github.com/ms-iot/windows-remote-arduino-samples.git

    The directory structure of what you get is:

windows-remote-arduino-samples    o remote-wiring       Microsoft.Maker.win8_1      Microsoft.Maker.win10     source    o win8_1      o win10

The latter two folders (win8_1 and win10) are just example apps (including the “blinky” example) which we will ignore for now. Both Maker versions make use of the same sources folder so for Windows 10 we need just:

windows-remote-arduino-samples     o remote-wiring       Microsoft.Maker.win10          source

to a suitable folder. I suggest one at the root of the drive, say, c:\wras10 as I have found that you can get some errors with an ARM build to do with path names being too long. You might want to also copy the .md files for reference. These can be opened in VS.

3.2 Open the solution file in Microsoft.Maker.win10

3.3 Set the target to Win32 build the solution.

Three builds are done. One for each of the three layers in the software stack..

3.4 Do same for the ARM configuration. If you have an x64 machine, then you might like to try that build as well.


[4] Create the HW LED UWP app

There is a "short-circuit" in this section for those who have done the previous Win 8.1 activity.

For this initial version of the app/s, a software button will turn a hardware LED on and another will turn it off. The LED will be connected to GPIO pin 5.

The “Blinky” documentation says that there are a number of ways to get and use these libraries. Ultimately Nuget will be the way but that is not yet available. You can reference these built versions in a general manner on your development system, The easiest way is to just add the required Universal app to the solution and reference them. We will use that method.

4.1 Add a new C# Windows Blank Universal app to the solution. (Note not Windows 8.1 this time):

Give it a suitable name. I called mine wrauwp: Windows Remote Arduino Universal app UWP.
Note that this time there is only ONE project created (UWP).. The XAML and CSharp code is the same for the desktop and mobile versions of the app. The difference is in how it is compiled.

The Serial and Bluetooth capabilities are needed in the pacakage manifest:

4.2 Open the package.appmanifest in the text editor (not its GUI) by View Code. The Internet Client capability is included at the bottom. Modify this section to:

In packkage.appmanifest

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

Also, if we were using USB-Serial rather than Bluetooth-Serial on the desktop, we would add a capability for that.

A reference to each of the relevant software layers is required:

4.3 Add references Firmata, RemoteWiring and Serial for the desktop UA (again only need do this for one project):

HINT: For those who have already done the previous Windows 8.1 you can now short-circuit what follows:

  • Copy the grid xml code from that project to MainPage.xaml in this new project.
  • You can now skip to testing the app on the target/s

For those continuing here …

4.4 Modify both UA’s Grid XAML to:

MainPage.xaml: UI
<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">     <Grid.RowDefinitions>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>    </Grid.RowDefinitions>    <Button Name="OffButton" Click="OffButton_Click" Grid.Row="0" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="White" Background="Green" FontSize="32">Off!</Button>    <Button Name="OnButton" Click="OnButton_Click" Grid.Row="1" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="White" Background="Red" FontSize="32">On!</Button></Grid>

Comment We only have one MainPage.cs this time, as there is only one app project…One Windows.
Previously there was one for the desktop and one for the phone, which we made common by placing one version in the share subproject.

All cs code will refer to MainPage.cs

4.7 In the MainPage class add the following declarations at the top of the class:

MainPage.cs Declarations

//Usb is not supported on Win8.1. To see the USB connection steps, refer to the win10 solution instead.BluetoothSerial bluetooth;RemoteDevice arduino; // The pins used. Note: Actual pinn numbers.private const int LED_PIN = 5;

4.8 in the MainPage constructor, after InitializeComponent() add:

In MainPage() the constructor

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

Replace FireFly-748B with your SPP.

4.9 Implement OnConnectionEstablished by add the following mthod to the class:

Add OnConnectionEstablished()

private void OnConnectionEstablished(){    //enable the buttons on the UI thread!    var action = Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, new Windows.UI.Core.DispatchedHandler(() => {        this.OnButton.IsEnabled = true;        this. OffButton.IsEnabled = true;         arduino.pinMode(LED_PIN, PinMode.OUTPUT);    }));}

4.10 And finally add the event handlers for the buttons to the class:

Add Button Event Handlers

private void OnButton_Click(object sender, RoutedEventArgs e){    //turn the LED connected to pin 5 ON    arduino.digitalWrite(5, PinState.HIGH);} private void OffButton_Click(object sender, RoutedEventArgs e){    //turn the LED connected to pin 5 OFF    arduino.digitalWrite(5, PinState.LOW);}

4.11 Test build the UWP app in x86, x64 and ARM configurations


[5] Deploying and testing the Universal apps.

In this section we will wire up the hardware LED to the Arduino device and run the app on the desktop, and a Windows 10 Phone*

Test on your desktop

5.1 Set the Desktop app as the Startup Project

5.2 Set the target to x86 and Local Machine. Rebuild the desktop UWP app

5.3 Connect the Arduino Pin 5 to a hardware LED. Provide GND, VCC and a suitable resistor in series.

As mentioned in a previous blog with respect to Windows 10 IoT Raspberry PI 2 GPIO I use a development board for implementing my testing IO such as LEDs, switches etc. If you do not have a similar board you might like to use the “Blinky” hardware configuration but you will need to reverse the polarity of pin setting in button handlers.

5.4 Power up the Arduino device and pair up the Bluetooth module with your desktop (Passkey=1234). .. I’ll assume you know how to do this.

5.5. Run the app.

5.6 It will probably ask you whether it’s OK for the app to connect to the Bluetooth device .. OK

5.7 Test the functionality of the app. Set a breakpoint in the button handler/s and check that you can debug.

5.8 Repeat 4.1 to 4.6 for x64 if you have a 64 bit desktop.

5.9 Turn off Bluetooth on your desktop

Now to test your Windows 10 Phone, assuming the phone is configured for development.

5.10 Turn on your phone, go to Settings/Bluetooth and turn it on. Pair with the Bluetooth module (Passkey = 1234).

5.11 Continuing with the Windows Universal app as the startup project ..

5.12 Set the Target to ARM,, Device and rebuild

5.11 Connect up the phone via USB Serial to the desktop and deploy the app.

Now to test the Raspberry PI 2

THIS IS A WORK IN PROGRESS. SEE NOTE AT END OF THIS SECTION

5.13 The Remote debugger is already installed and active on the RPI2 configured for Win 10 IoT.

5.14 Determine the IP address of the RPI2, eg with the Windows IoT Core Watcher

5.15 In Project Properties-Debug set the target to Remote Machine, No authentication and enter the IP address

5.16 Rebuild the UWP app

5.17 Deploy and test the app on the RPI2.

I haven't got the RPI2 version to connect over Bluetooth yet:

  • Bluetooth in the main isn't yet supported
  • Please leave any comments if you have any ideas or success with this.
  • I'll update here when I make progress
The Bluetooth dongle is loaded on the RPI2

[6] “Pretty up” the UI

The following will pretty up the UI and add Bluetooth Connect and Disconnect buttons.

6.1 Modify the UI GRID XAML code to (PS: Note change to previous buttons grid rows):

Add two Buttons &amp;amp;amp;

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">     <Grid.RowDefinitions>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="32"/>        <RowDefinition Height="Auto"/>    </Grid.RowDefinitions>    <Button Name="ConnectButton" Click="ConnectButton_Click" Grid.Row="0" IsEnabled="True" HorizontalAlignment="Stretch" BorderBrush="Lime" Foreground="Lime" FontSize="32">Connect</Button>    <Button Name="OffButton" Click="OffButton_Click" Grid.Row="1" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="White" Background="Green" FontSize="32">Off!</Button>    <Button Name="OnButton" Click="OnButton_Click" Grid.Row="2" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="White" Background="Red" FontSize="32">On!</Button>    <Button Name="DisconnectButton" Click="DisconnectButton_Click" Grid.Row="3" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="Red" BorderBrush="Red" FontSize="32">Disconnect</Button>    <ProgressRing x:Name="progress1" Grid.Row="5" Height="50" Visibility="Visible"/></Grid>

The UI has larger buttons and is more colorful providing better usability. I arrived at this after user testing it with my 4 year old granddaughter!.

The ProgressRing is visible and circulates whilst the app is connecting.

6.2 Insert at the bottom of OnConnectionEstablished() :

In OnConnectionEstablished()

//BT is connected so turn off progress ringthis.progress1.IsActive = false;this.progress1.Visibility = Visibility.Collapsed;

6.3 Add the following handlers for the Connect and DisConnect buttons:

Add new button's eventhandlers

private void ConnectButton_Click(object sender, RoutedEventArgs e){    //these parameters don't matter for bluetooth- Arduino Firmata, except  SerialConfig.SERIAL_8N1    bluetooth.begin(115200, SerialConfig.SERIAL_8N1);    this.ConnectButton.IsEnabled = false;     //Connecting BT so show progress ring    this.progress1.IsActive = true;    this.progress1.Visibility = Visibility.Visible;} private void DisconnectButton_Click(object sender, RoutedEventArgs e){    bluetooth.end();    this.OnButton.IsEnabled = false;    this.OffButton.IsEnabled = false;    this.ConnectButton.IsEnabled = true;    this.DisconnectButton.IsEnabled = false;}

6.4 Comment out or remove the following line from MainPageConstructor as its now in the Connect button handler:

bluetooth.begin(115200, SerialConfig.SERIAL_8N1);

6.5 Add the following state management to the OnButton handler

In OnButton_Cllick()

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

6.6 And the following to the OffButton handler:

In OffButton_Click

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

6.7 Deploy and test the app on all three (4) targets as in section 5


[7] Add a Pushbutton input

In this extension to the Windows 8.1 Universal apps, a pushbutton GPIO input, at Arduino Pin 5, is facilitated and its state is displayed in the UI. The input will initially be sensed by periodically reading the value. 

The functionality will then be improved by implementing a handler for the DigitalPinChanged event

7.1 Modify the Grid control in the UI XAML code for both UA as follows:

Add a textbox to UI

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">     <Grid.RowDefinitions>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="32"/>        <RowDefinition Height="Auto"/>        <RowDefinition Height="Auto"/>    </Grid.RowDefinitions>    <Button Name="ConnectButton" Click="ConnectButton_Click" Grid.Row="0" IsEnabled="True" HorizontalAlignment="Stretch" BorderBrush="Lime" Foreground="Lime" FontSize="32">Connect</Button>    <Button Name="OffButton" Click="OffButton_Click" Grid.Row="1" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="White" Background="Green" FontSize="32">Off!</Button>    <Button Name="OnButton" Click="OnButton_Click" Grid.Row="2" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="White" Background="Red" FontSize="32">On!</Button>    <Button Name="DisconnectButton" Click="DisconnectButton_Click" Grid.Row="3" IsEnabled="False" HorizontalAlignment="Stretch" Foreground="Red" BorderBrush="Red" FontSize="32">Disconnect</Button>    <ProgressRing x:Name="progress1" Grid.Row="5" Height="50" Visibility="Visible"/>    <TextBox Name="TxtPin6" Visibility="Visible" Grid.Row="6" Text="Pushbutton: HIGH"></TextBox></Grid>

7.2 In the MainPage class specify the the input pin:

- In declarations at the top of the class add the input pin:

In MainPage Declarations

private const int PB_PIN = 6;

- In the OnConnectionEstablished handler set it to input::

In OnConnectionEstablished

arduino.pinMode(PB_PIN, PinMode.INPUT);

7.3, Add a timer to poll the input as follows:

- In declarations at the top of the class:

In MainPage Declarations

// In Poll mode timer ticks sample the inputsprivate DispatcherTimer pbPolltimer;

- In the constructor set the timer:

In MainPage()

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

- Add its timer tick event handler

Add Poll Timer Tick handler

PinState pbPinValue = PinState.LOW; private void PBTimer_Tick(object sender, object e){    PinState pbPinValueTemp = arduino.digitalRead(6);    Pushbutton_Pressed(pbPinValueTemp);}

- Implement PushButton_Pressed():

Add PushButton_Pressed()

private void Pushbutton_Pressed(PinState pbPinValueTemp){    if (pbPinValue != pbPinValueTemp)    {        //Write value if changed        TxtPin6.Text = "Pushbutton: " + pbPinValueTemp.ToString();        pbPinValue = pbPinValueTemp;    }}

7.4 We need a pushbutton switch. Thankfully my development board provides these so I just use that. If you don’t have such a beast, then implement the circuit opposite.

In this extension to the Windows 8.1 Universal apps, a pushbutton GPIO input, at Arduino Pin 5, is facilitated and its state is displayed in the UI. The input will initially be sensed by periodically reading the value. With the Win 10 IoT Raspberry PI 2 (RPI2), it has been reported that there are some bugs with how often the digital inputs are registered, which will be fixed in the RTM for Win 10 IoT.

The functionality will then be improved by implementing a handler for the DigitalPinChanged event

Debouncing can be improved for this situation in hardware by:

- Put a small capacitor across the switch to add some hardware debouncing as an RC delay.

- Also add a Schmidt trigger to this circuit.

With the RPI2 there is an option to add debouncing through software configuration.

With the RPI2 there is an option to add debouncing through software configuration.

7.5 Build, deploy and test the app on the targets as previous

Let’s add a software simulated LED to the UI to display the state of the switch.

7.6 Add the following to the UI in the grid XAMLcode in both Universal apps:

- Add another Row Definition (at bottom )::            

<RowDefinition Height="Auto"/>

- Add the following ellipse control to that row:

Add an ellipse to the UI

<Ellipse x:Name="PBStatusLED" Fill="#FF96969B" Grid.Row="7" Stroke="Black" Width="64" IsRightTapEnabled="False" IsTapEnabled="True" IsDoubleTapEnabled="False" Height="64" VerticalAlignment="Top" HorizontalAlignment="Center" />

7.7 Add two color brush definitions to the MainPage class declarations at the top:

Add colors in the Declarations

// Colors for ellipse when hardware pushbutton is pressed/not pressedprivate SolidColorBrush redBrush = new SolidColorBrush(Windows.UI.Colors.Red); private SolidColorBrush grayBrush = new SolidColorBrush(Windows.UI.Colors.LightGray);

7.8 Implement the LED’s manipulation with these colors as follows:

- In the class constructor set its initial color:

In the constructor

//Start with off color for ellipsethis.PBStatusLED.Fill = grayBrush;

- In PushButtonPressed() set its color depending upon the button’s state:

Add to Pushbutton_Pressed()

switch (pbPinValue){    case PinState.HIGH:        this.PBStatusLED.Fill = redBrush;        break;    case PinState.LOW:        this.PBStatusLED.Fill = grayBrush;        break;}

7.9 Build, deploy and test the apps on the targets ..Wala!

Now to improve this code using the digital event.

7.10 Comment out all code to do with the timer, but leave the PushButtonPressed() function; hence the reason for separate to the timer tick event handler.

7.11 Add the event delegate specification to the OnConnectionEstablished() event handler within the action

Add to 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

<ProgressBar x:Name="analogBar" Value="0" Margin="10" Maximum="255" Height="32" IsIndeterminate="False" Grid.Row="8" Foreground="Green"/>

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 indexint 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.zipC#
An extended version of "Blinky"
Input, Output, Analog Input
Fancier UI
No preview (download only).

Schematics

Arduino Prototype Shield for mounting the Bluetooth module
Clip image010 thumb2 2

Comments

Similar projects you might like

Windows 8.1 IoT: Windows Remote Arduino and Universal apps

Project tutorial by David Jones

  • 2,577 views
  • 1 comment
  • 8 respects

Windows Remote Arduino

Project tutorial by Team Windows IoT

  • 166,232 views
  • 167 comments
  • 339 respects

Home Automation Using Raspberry Pi 2 And Windows 10 IoT

Project tutorial by Anurag S. Vasanwala

  • 297,314 views
  • 98 comments
  • 706 respects

Windows IOT - Automate your power outlets

Project tutorial by Syed Sanoor

  • 22,136 views
  • 13 comments
  • 48 respects

Bluetooth RC Car with Remote Arduino

Project tutorial by Team Windows IoT

  • 41,621 views
  • 3 comments
  • 79 respects
Add projectSign up / Login