Generic Serial Bluetooth with Win 10 IoT-Core RPI2

Further

This project is discussed in detail in embedded101.com:

"Win 10 IoT-Core: Bluetooth Universal Windows Serial App"

About

This project is a Universal Windows App that connects an IoT-Core device such as a Raspberry PI 2 to an embedded Bluetooth device over the Bluetooth Serial Profile using a genetic Bluetooth USB dongle.

Background

.Bluetooth supports peer to peer networking over a short range. Unlike a Wi-Fi network, Bluetooth connectivity is one to one. Two devices can connect and interact. For example, two devices may connect in a symmetric manner using the serial profile and pas raw data between them. Generally though, Bluetooth connectivity is asymmetric with one end generating a specific data format to be consumed at the other end. For example a mobile phone can implement the A2DP (Advanced Audio Distribution Profile) Profile and stream audio to a head set that implements the HSP (Headset) Profile OBEX (Object Exchange) is a symmetric connection between two devices as they exchange data between them.

The Microsoft IOT-Core Bluetooth Sample project uses the GATT (Generic Attribute Profile Profile). This provides profile discovery and description services for the Bluetooth Low Energy protocol. With this protocol simple low power devices can be connected at one end generating data to be consumed by a complex processor.

This is a far simpler project than the Microsoft sample. It is only concerned with the more generic SPP (Serial Port Profile) which is based upon the RFCOMM profile. It was developed with a very old USB Bluetooth dongle and so should work with any Bluetooth dongle.

The IoT App

This app is a simple Bluetooth Serial Universal Windows (Windows 10) test app. It starts by enumerating (as a list) all devices Bluetooth paired to the device where the app is running. One is selected by double clicking which initiates connection. Text to send is entered in a Textbox and sent when a button is pressed. The app automatically receives any text sent to it ( and displays it). Hence when the endpoint (as above) simply echoes the text its received, the sent text should reappear in the reception box on the UW app.

The Endpoint

For testing an Arduino Uno with a Bluetooth adapter is used. It has a simple shield that just echoes back any characters its receives over the Bluetooth connection:

The Shield Setup:

// A serial loop back app
// Past setup
// Initiated by connected system
// Note can be used with Bluetooth where the RxTx of the BT device
// are connected to the TxRx of the Arduino board.
// Need to disconnect BT adapter for programming though.
void setup() {
     // My adapter is set to this BAUD 115200
     // This is the Arduino to BT adapter port rate
     // Set when the BT adapter is in command mode.
     // Its NOT the BT rate which you can't set.
     Serial.begin(115200);
     delay(333);
     while (!Serial)
         ;
     delay(1000);
     Serial.println("The quick brown fox jumps over the lazy dog!");
}

The Shield Loop:

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

Pairing

Bluetooth is a peer to peer scenario. Before they can connect over Bluetooth they must be paired. This is not done within the app. Pairing with a passkey can be problematic between embedded devices as they are often headless and may not support popups (as IoT-Core does not). There is a IoT-Core web portal for doing this as well as a command line utility on the device that can be run over an SSH shell. The most recent version of the OS web portal  supports passkey pairing which was missing around the time of Windows 10 RTM. "Win 10 IoT-Core: Bluetooth Universal Windows Serial App" discusses pairing in this context in detail.

Starting the project

The app project is created using in Visual Studio 2015 using the  Universal Windows app template:

New Project-->Visual C#->Windows->Blank App (Universal Windows)

Creating the App UI

The UI is implemented in XAML

Create the UI as per the layout as above (or similar):

The UI is quite straight forward and is created as follows:

• All text elements are TextBlocks except the SendText which is a TextBox
• SendText accepts CarriageReturn (ie is Multiline)
• The Recvd text has WrapText enabled (ie is Multiline)
• UI elements are organised in rows using a StackPanel set to horizontal orientation
• These StackPanels are then stacked with a StackPanel set to vertical orientation, along with the ListBox.

You may prefer to layout the UI using Relative StackPanels or use Grid rows and columns etc.

The ConnectDevices is a ListBox with a Binding Source set to PairedDevices(see later) and an ItemTemplate consisting of a TextBlock bound to the Name property of PairedDevices (see later).

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

App Configuration

• The app make no use of IOT-Core features so will not require any Extension References.
• The app will need some specific capabilities for Bluetooth and Serial added to Package.appxmanifest.
• Unfortunately, the UI you get for this if you double click on that file in Solution Explorer doesn’t support adding these capabilities and so you need to add them manually by right clicking on the file in Solution Explorer and select Open With->XML Editor.

Modify the capabilities section (at the bottom) to:

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

The internetClient capability will already be there. Its not needed for this app so you may wish to remove it. I leave it in.

PairedDevice Information

At the app start the paired devices are enumerated using:

DeviceInformationCollection DeviceInfoCollection

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

This collection is then turned into an ObservableCollection that it can be used in the ListBox:

_pairedDevices = new ObservableCollection<PairedDeviceInfo>();

The DeviceInfoCollection is iterated through creating a PairedDeviceInfo object for each item which is then added to the _pairedDevices collection.

PairedDeviceInfo is a class with properties:

Name <string>

Id <string>

DeviceInfo <DeviceInformation>

The class has an appropriate constructor.

DeviceInformation is Windows.Devices.Enumeration.DeviceInformation

In the listbox of paired devices, the Name field is (bound) displayed.

When a device is selected (double clicked) the endpoint’s DeviceInformation is actually part of the selected menu item and so is used for establishing the  connection.

Connection

The DeviceInformation is used to get the RFCOMM service. The connection is then established as a StreamSocket using the Endpoint HostName (actually its Bluetooth Mac Address) and the ServiceName string.

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

If all is well then we have a connection .. the socket will be meaningful (not null).

Of course this is error trapped (try-catch)

Send text and Receive text make use of the socket’s InputStream and OutputStream properties.

Receive Text

Receiving text should be started first as it runs as a separate thread. It runs an async wait to get serial input, handles the input then runs another async serial receive .. all in a loop. This loops continuous until a cancellation is generated.

private async void Listen()
{
     ReadCancellationTokenSource = new CancellationTokenSource();
     if (_socket.InputStream != null)
     {
         dataReaderObject = new DataReader(_socket.InputStream);
         // keep reading the serial input
         while (true)
         {
              await ReadAsync(ReadCancellationTokenSource.Token);
         }
     }
}
DataReader dataReaderObject;
private CancellationTokenSource ReadCancellationTokenSource;

private async Task ReadAsync(CancellationToken cancellationToken)
{     uint ReadBufferLength = 1024;
      // If task cancellation was requested, comply
      cancellationToken.ThrowIfCancellationRequested();

     // Set InputStreamOptions to complete the asynchronous read operation   when one or more bytes is available
     dataReaderObject.InputStreamOptions = InputStreamOptions.Partial;
     // Create a task object to wait for data on the serialPort.InputStream
     loadAsyncTask = dataReaderObject.LoadAsync(ReadBufferLength).AsTask(cancellationToken);
     // Launch the task and wait
     UInt32 bytesRead = await loadAsyncTask;
     if (bytesRead > 0)
     {
         string recvdtxt = dataReaderObject.ReadString(bytesRead);
     }
}

Send Text

Whilst the received text is performed asynchronously as the arrival of text is nondeterministic from the app’s perspective, sent text is actioned from the app’s UI and so is essentially synchronous (although a await is used to free up the UI).

private async void Send(string msg)
{
     Task storeAsyncTask;
     DataWriter dataWriteObject = new DataWriter(_socket.OutputStream);
     dataWriteObject.WriteString(msg);
     // Launch an async task to complete the write operation
     storeAsyncTask = dataWriteObject.StoreAsync().AsTask();
     UInt32 bytesWritten = await storeAsyncTask;
}

Button States

The command buttons are enabled and disabled depending upon the state of the app. For example Send and Start Recv buttons are disabled when the app isn’t connected but become enabled when the app is connected, etc.

Enjoy! :)