Virtual com port bluetooth windows

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Runtime.InteropServices;

using System.Text;

namespace BluetoothDiagnostics

{

public sealed class BluetoothComPort

{

/// <summary>

/// Returns a collection of all the Bluetooth virtual-COM ports on the system.

/// </summary>

/// <returns></returns>

public static IReadOnlyList<BluetoothComPort> FindAll()

{

List<BluetoothComPort> ports = new List<BluetoothComPort>();

IntPtr handle = NativeMethods.SetupDiGetClassDevs(ref NativeMethods.GUID_DEVCLASS_PORTS, null, IntPtr.Zero, NativeMethods.DIGCF.PRESENT);

if (handle != IntPtr.Zero)

{

try

{

NativeMethods.SP_DEVINFO_DATA dat = new NativeMethods.SP_DEVINFO_DATA();

dat.cbSize = Marshal.SizeOf(dat);

uint i = 0;

while (NativeMethods.SetupDiEnumDeviceInfo(handle, i++, ref dat))

{

string remoteServiceName = string.Empty;

StringBuilder sbid = new StringBuilder(256);

int size;

NativeMethods.SetupDiGetDeviceInstanceId(handle, ref dat, sbid, sbid.Capacity, out size);

Debug.WriteLine(sbid);

long addr = GetBluetoothAddressFromDevicePath(sbid.ToString());

// only valid if an outgoing Bluetooth port

if (addr != long.MinValue && addr != 0)

{

IntPtr hkey = NativeMethods.SetupDiOpenDevRegKey(handle, ref dat, NativeMethods.DICS.GLOBAL, 0, NativeMethods.DIREG.DEV, 1);

var key = Microsoft.Win32.RegistryKey.FromHandle(new Microsoft.Win32.SafeHandles.SafeRegistryHandle(hkey, true));

object name = key.GetValue(«PortName»);

var pkey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(«SYSTEM\\CurrentControlSet\\Services\\BTHPORT\\Parameters\\Devices\\» + addr.ToString(«x12»));

if (pkey != null)

{

foreach (string nm in pkey.GetSubKeyNames())

{

if (nm.StartsWith(«ServicesFor»))

{

var skey = pkey.OpenSubKey(nm);

string s = sbid.ToString();

//bluetooth service uuid from device id string

int ifirst = s.IndexOf(«{«);

string uuid = s.Substring(ifirst, s.IndexOf(«}») — ifirst+1);

var ukey = skey.OpenSubKey(uuid);

// instance id from device id string

string iid = s.Substring(s.LastIndexOf(«_»)+1);

var instKey = ukey.OpenSubKey(iid);

// registry key contains service name as a byte array

object o = instKey.GetValue(«PriLangServiceName»);

if(o != null)

{

byte[] chars = o as byte[];

remoteServiceName = Encoding.UTF8.GetString(chars);

remoteServiceName = remoteServiceName.Substring(0, remoteServiceName.IndexOf(‘\0’));

}

}

}

}

ports.Add(new BluetoothComPort(sbid.ToString(), addr, name.ToString(), remoteServiceName));

key.Dispose();

}

}

}

finally

{

NativeMethods.SetupDiDestroyDeviceInfoList(handle);

}

}

return ports;

}

private string _deviceId;

private long _bluetoothAddress;

private string _portName;

private string _remoteServiceName;

internal BluetoothComPort(string deviceId, long bluetoothAddress, string portName, string remoteServiceName)

{

_deviceId = deviceId;

_bluetoothAddress = bluetoothAddress;

_portName = portName;

_remoteServiceName = remoteServiceName;

}

public string DeviceId

{

get

{

return _deviceId;

}

}

public long BluetoothAddress

{

get

{

return _bluetoothAddress;

}

}

public string PortName

{

get

{

return _portName;

}

}

public string RemoteServiceName

{

get

{

return _remoteServiceName;

}

}

private static long GetBluetoothAddressFromDevicePath(string path)

{

if (path.StartsWith(«BTHENUM»))

{

int start = path.LastIndexOf(‘&’);

int end = path.LastIndexOf(‘_’);

string addressString = path.Substring(start + 1, (end — start) — 1);

// may return zero if it is an incoming port (we’re not interested in these)

return long.Parse(addressString, System.Globalization.NumberStyles.HexNumber);

}

// not a bluetooth port

return long.MinValue;

}

private static class NativeMethods

{

// The SetupDiGetClassDevs function returns a handle to a device information set that contains requested device information elements for a local machine.

[DllImport(«setupapi.dll», SetLastError = true, CharSet = CharSet.Auto)]

internal static extern IntPtr SetupDiGetClassDevs(

ref Guid classGuid,

[MarshalAs(UnmanagedType.LPTStr)] string enumerator,

IntPtr hwndParent,

DIGCF flags);

// The SetupDiEnumDeviceInfo function returns a SP_DEVINFO_DATA structure that specifies a device information element in a device information set.

[DllImport(«setupapi.dll», SetLastError = true, CharSet = CharSet.Auto)]

[return: MarshalAs(UnmanagedType.Bool)]

internal static extern bool SetupDiEnumDeviceInfo(

IntPtr deviceInfoSet,

uint memberIndex,

ref SP_DEVINFO_DATA deviceInfoData);

// The SetupDiDestroyDeviceInfoList function deletes a device information set and frees all associated memory.

[DllImport(«setupapi.dll», SetLastError = true, CharSet = CharSet.Auto)]

[return: MarshalAs(UnmanagedType.Bool)]

internal static extern bool SetupDiDestroyDeviceInfoList(IntPtr deviceInfoSet);

// The SetupDiGetDeviceInstanceId function retrieves the device instance ID that is associated with a device information element.

[DllImport(«setupapi.dll», SetLastError = true, CharSet = CharSet.Auto)]

[return: MarshalAs(UnmanagedType.Bool)]

internal static extern bool SetupDiGetDeviceInstanceId(

IntPtr deviceInfoSet,

ref SP_DEVINFO_DATA deviceInfoData,

System.Text.StringBuilder deviceInstanceId,

int deviceInstanceIdSize,

out int requiredSize);

//static Guid GUID_DEVCLASS_BLUETOOTH = new Guid(«{E0CBF06C-CD8B-4647-BB8A-263B43F0F974}»);

internal static Guid GUID_DEVCLASS_PORTS = new Guid(«{4d36e978-e325-11ce-bfc1-08002be10318}»);

[DllImport(«setupapi.dll», SetLastError = true)]

internal static extern IntPtr SetupDiOpenDevRegKey(IntPtr DeviceInfoSet, ref SP_DEVINFO_DATA DeviceInfoData,

DICS Scope, int HwProfile, DIREG KeyType, int samDesired);

[Flags]

internal enum DICS

{

GLOBAL = 0x00000001, // make change in all hardware profiles

CONFIGSPECIFIC = 0x00000002, // make change in specified profile only

}

internal enum DIREG

{

DEV = 0x00000001, // Open/Create/Delete device key

DRV = 0x00000002, // Open/Create/Delete driver key

}

// changes to follow.

// SETUPAPI.H

[Flags()]

internal enum DIGCF

{

PRESENT = 0x00000002, // Return only devices that are currently present in a system.

ALLCLASSES = 0x00000004, // Return a list of installed devices for all device setup classes or all device interface classes.

PROFILE = 0x00000008, // Return only devices that are a part of the current hardware profile.

}

[StructLayout(LayoutKind.Sequential)]

internal struct SP_DEVINFO_DATA

{

internal int cbSize; // = (uint)Marshal.SizeOf(typeof(SP_DEVINFO_DATA));

internal Guid ClassGuid;

internal uint DevInst;

internal IntPtr Reserved;

}

}

}

}

Bluetooth Serial Ports

By far the easiest and best way to use a serial port connection is to use BluetoothClient with service class BluetoothService.SerialPort, i.e. using code very much like shown in General Bluetooth Data Connections. That gets one a .NET Stream to read and write from. Both BluetoothClient and virtual serial ports use the RFCOMM protocol so the two are equivalent. This method is much easier to set-up that a virtual serial port, there is no global state to configure etc; and is also more robust, for instance if the peer device is taken out of range or turned-off one learns this directly soon after, whereas with a serial port one has to use timeouts and retries to detect it.

However there are cases where a virtual serial port is required, for instance where another program needs to access the connection — a common case is where your program is configuring a connection that will be used by a printer driver utility.

Note that RFCOMM/SPP only allows one connection from a remote device to each service. So do not use BluetoothClient and a virtual Serial port to connect to the same service at the same time; the second one will fail to connect.

Win32 + Microsoft Bluetooth stack

On Win32, to create a Bluetooth virtual serial port one can use BluetoothDeviceInfo.SetServiceState, passing in service class SerialPort. Unfortunately the name of the COM port created is not returned — that’s because the native API does not tell! One way to find the name of the port created is to call the System.IO.Ports.SerialPort.GetPortNames method before and after the SetServiceState call and see which name is new.

BluetoothAddress addr = ...  // e.g. BluetoothAddress.Parse("002233445566");
BluetoothDeviceInfo device = new BluetoothDeviceInfo(addr);  // Or from discovery etc
bool state = true;
device.SetServiceState(BluetoothService.SerialPort, state, true);

Windows Mobile/CE + Microsoft Bluetooth stack

On Windows Mobile, two methods to create a port exist in the library, the first is class BluetoothSerialPort, this creates a connection immediately but the underlying API it uses is rather unreliable, and it seems not to work at all on various device types. The second is BluetoothDeviceInfo.SetServiceState as for Win32, this manually configures the necessary Registry settings and is reliable but might require a reboot before the port becomes available, and again the name of the new port is not returned.

Widcomm/Broadcom

On Widcomm, we recently added support for their CSppClient class. Currently this is exposed by method WidcommSerialPort.Create — I’ll integrate it with BluetoothSerialPort sometime. I haven’t used the serial ports on the other platforms very much, but on testing the support on Widcomm I found some specific behaviour when the connection is broken — by the two devices going out of range or similar. When that happens the connection is broken (e.g. a BluetoothListener connection at the other end see End-Of-Stream) and we see a DISCONNECT event raised by the CSppClient class. The port does not seems to reconnect. If one closes and reopens the SerialPort (e.g. COM8) from the client program then the Widcomm «choose device dialog» is shown to the user when we might have hoped that the connection was made back to the previous service.
:We will probably need to have some way to reconnect this. If we reconnect automatically internally inside WidcommSerialPort can we be sure that we’ll get the same COM port number assigned. Or should we provide an event which is raised when the connection is lost and let the consumer program redo the connection manually. Or somewhere in between?

However this code does not work when I tested it on the Win32 installation — maybe because my installation version is too old or something. Let me know if you get it to work for you. There is also a different API in Widcomm Win32 with method CBtIf::CreateCOMPortAssociation etc, I’d be happy to accept patches for that — probably in WidcommBluetoothDeviceInfo.SetServiceState.

Getting Virtual COM Port Names

This article describes remote configuration of LM048/LM058 Adapter using a Bluetooth USB Adapter or in-built Bluetooth of PC/Laptop. For Setup procedure please look at the article LM048: Remote Configuration of Serial Adapter via Bluetooth Connection

The remote configuration procedure is described using a Windows 7 Professional Desktop PC with Bluetooth USB Dongle, LM149 Software and Hercules Setup Utility Serial Terminal. The same instructions apply if you are using a device (e.g. notebook or tablet) with built-in Bluetooth.

Setting up Virtual COM port for Serial Adapter

Follow the below steps to configure serial adapter over Bluetooth.

• Power up the Bluetooth Serial Adapter. The LED status should be RED: ON, BLUE: Blinking, AMBER/GREEN: OFF
• Insert the Bluetooth USB Adapter and discover the serial adapter (right-click on the system tray Bluetooth icon and then Show Devices) and add to Bluetooth Devices. A virtual Serial Port can then be created as shown in screenshots below

Картинка с сайта: wiki.lm-technologies.com

Картинка с сайта: wiki.lm-technologies.com

Картинка с сайта: wiki.lm-technologies.com

Картинка с сайта: wiki.lm-technologies.com

• Check the services tab of Bluetooth Device find the virtual Bluetooth COM port number

Картинка с сайта: wiki.lm-technologies.com

Remote Login Authentication Disabled

Remote Configuration using Serial Terminal

After adding the Bluetooth Serial Adapter to PC Bluetooth Devices, user can also use a serial terminal program instead of LM149 Software. The below steps are shown using Hercules Setup Utility Serial Terminal on a Windows 7 PC.

1/ Open the Bluetooth Virtual COM Port. This will create the Bluetooth connection with the Serial Adapter.

Картинка с сайта: wiki.lm-technologies.com

2/ Make sure the End of Line (EOL) character setting is set to Carriage Return (CR) on the serial terminal

Картинка с сайта: wiki.lm-technologies.com

3/ Send the handshake sequence 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0x0D as Hex characters or via “Send File” feature depending on the Serial terminal feature. The handshake file can be downloaded from here handshake.txt

Картинка с сайта: wiki.lm-technologies.com

4/ Once the handshake sequence is processed the user will get a reply 0xBB 0xAA when authentication is disabled or 0xBB 0xBB when authentication is enabled

Картинка с сайта: wiki.lm-technologies.com

5/ When handshake sequence is complete, user can send AT Commands and get a response. The user can use AT Commands to read or change settings. Please refer the LM048 AT Command Manual for the list of all AT Commands. Please note user will not see echo of AT Commands sent to LM048 but only responses as shown in the screenshot below for command AT, AT+VER, AT+ENQ

Картинка с сайта: wiki.lm-technologies.com

6/ To exit remote configuration, send AT+AUTO command. OK response will be received and the remote serial adapter will switch back to data mode. To disconnect the connection, please close the COM port.

Картинка с сайта: wiki.lm-technologies.com

Remote Login Authentication Enabled

Remote Login authentication is enabled when user sets a remote login password using the AT+RLOGIN command. The RLOGIN password should be between 5-16 characters long and have atleast 1 digit. The remote login password can be set only using a serial terminal locally. The remote login password cannot be read or changed remotely over a Bluetooth connection.

For setting remote configuration authentication please see LM048: Remote Configuration of Serial Adapter via Bluetooth Connection

Most of the steps of remote configuration are same as described in the except there is an extra authentication step before the adapter switches to remote configuration mode.

When the handshake sequence 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0x0D is sent to remote adapter, it responds with 0xBB 0xBB instead of 0xBB 0xAA when authentication is disabled. Remote login authentication requests can be handled with LM149 Software v1.6 or above as well as serial terminal. Both these scenarios are described below. Please note the remote login password for below section is LMT1234

Handling Remote Login Authentication Using Serial Terminal

When remote authentication is enabled, the procedure for remote configuration is same as described in section Remote Configuration using Serial Terminal except there is an extra step for remote authentication. The handshake sequence 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0xAA 0x0D is replied with 0xBB 0xBB. The user has to supply password using command AT+RLOGIN. If password is correct, handshake sequence is complete and user gets OK response. If password is not correct, user gets ERROR response and handshake sequence fails. Please note the AT+RLOGIN response from user is not echoed, so not visible in the serial terminal window. This is shown in the screenshot below.

Картинка с сайта: wiki.lm-technologies.com

Once remote authentication is successful and handshake is complete, rest of the procedure to read and change settings is same as described in section Remote Configuration using Serial Terminal.